<?xml version="1.0"?>
<doc>
    <assembly>
        <name>ProjNET</name>
    </assembly>
    <members>
        <member name="T:SharpMap.CoordinateSystems.Transformations.GeographicTransform">
            <summary>
            The GeographicTransform class is implemented on geographic transformation objects and
            implements datum transformations between geographic coordinate systems.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.MathTransform">
            <summary>
            Abstract class for creating multi-dimensional coordinate points transformations.
            </summary>
            <remarks>
            If a client application wishes to query the source and target coordinate 
            systems of a transformation, then it should keep hold of the 
            <see cref="T:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation"/> interface, and use the contained 
            math transform object whenever it wishes to perform a transform.
            </remarks>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.IMathTransform">
            <summary>
            Transforms muti-dimensional coordinate points.
            </summary>
            <remarks>
            If a client application wishes to query the source and target coordinate 
            systems of a transformation, then it should keep hold of the 
            <see cref="T:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation"/> interface, and use the contained 
            math transform object whenever it wishes to perform a transform.
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransform.Identity">
            <summary>
            Tests whether this transform does not move any points.
            </summary>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransform.Derivative(System.Double[])">
            <summary>
            Gets the derivative of this transform at a point. If the transform does 
            not have a well-defined derivative at the point, then this function should 
            fail in the usual way for the DCP. The derivative is the matrix of the 
            non-translating portion of the approximate affine map at the point. The
            matrix will have dimensions corresponding to the source and target 
            coordinate systems. If the input dimension is M, and the output dimension 
            is N, then the matrix will have size [M][N]. The elements of the matrix 
            {elt[n][m] : n=0..(N-1)} form a vector in the output space which is 
            parallel to the displacement caused by a small change in the m'th ordinate 
            in the input space.
            </summary>
            <param name="point"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransform.GetCodomainConvexHull(System.Collections.Generic.List{System.Double})">
            <summary>
            Gets transformed convex hull.
            </summary>
            <remarks>
            <para>The supplied ordinates are interpreted as a sequence of points, which generates a convex
            hull in the source space. The returned sequence of ordinates represents a convex hull in the 
            output space. The number of output points will often be different from the number of input 
            points. Each of the input points should be inside the valid domain (this can be checked by 
            testing the points' domain flags individually). However, the convex hull of the input points
            may go outside the valid domain. The returned convex hull should contain the transformed image
            of the intersection of the source convex hull and the source domain.</para>
            <para>A convex hull is a shape in a coordinate system, where if two positions A and B are 
            inside the shape, then all positions in the straight line between A and B are also inside 
            the shape. So in 3D a cube and a sphere are both convex hulls. Other less obvious examples 
            of convex hulls are straight lines, and single points. (A single point is a convex hull, 
            because the positions A and B must both be the same - i.e. the point itself. So the straight
            line between A and B has zero length.)</para>
            <para>Some examples of shapes that are NOT convex hulls are donuts, and horseshoes.</para>
            </remarks>
            <param name="points"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransform.GetDomainFlags(System.Collections.Generic.List{System.Double})">
            <summary>
            Gets flags classifying domain points within a convex hull.
            </summary>
            <remarks>
             The supplied ordinates are interpreted as a sequence of points, which 
            generates a convex hull in the source space. Conceptually, each of the 
            (usually infinite) points inside the convex hull is then tested against
            the source domain. The flags of all these tests are then combined. In 
            practice, implementations of different transforms will use different 
            short-cuts to avoid doing an infinite number of tests.
            </remarks>
            <param name="points"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransform.Inverse">
            <summary>
            Creates the inverse transform of this object.
            </summary>
            <remarks>This method may fail if the transform is not one to one. However, all cartographic projections should succeed.</remarks>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransform.Transform(System.Double[])">
            <summary>
            Transforms a coordinate point. The passed parameter point should not be modified.
            </summary>
            <param name="point"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransform.TransformList(System.Collections.Generic.List{System.Double[]})">
            <summary>
            Transforms a list of coordinate point ordinal values.
            </summary>
            <remarks>
            This method is provided for efficiently transforming many points. The supplied array 
            of ordinal values will contain packed ordinal values. For example, if the source 
            dimension is 3, then the ordinals will be packed in this order (x0,y0,z0,x1,y1,z1 ...).
            The size of the passed array must be an integer multiple of DimSource. The returned 
            ordinal values are packed in a similar way. In some DCPs. the ordinals may be 
            transformed in-place, and the returned array may be the same as the passed array.
            So any client code should not attempt to reuse the passed ordinal values (although
            they can certainly reuse the passed array). If there is any problem then the server
            implementation will throw an exception. If this happens then the client should not
            make any assumptions about the state of the ordinal values.
            </remarks>
            <param name="points"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransform.Invert">
            <summary>
            Reverses the transformation
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.IMathTransform.DimSource">
            <summary>
            Gets the dimension of input points.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.IMathTransform.DimTarget">
            <summary>
            Gets the dimension of output points.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.IMathTransform.WKT">
            <summary>
            Gets a Well-Known text representation of this object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.IMathTransform.XML">
            <summary>
            Gets an XML representation of this object.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.MathTransform.R2D">
            <summary>
            R2D
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.MathTransform.D2R">
            <summary>
            D2R
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.MathTransform.Identity">
            <summary>
            Tests whether this transform does not move any points.
            </summary>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.MathTransform.Derivative(System.Double[])">
            <summary>
            Gets the derivative of this transform at a point. If the transform does 
            not have a well-defined derivative at the point, then this function should 
            fail in the usual way for the DCP. The derivative is the matrix of the 
            non-translating portion of the approximate affine map at the point. The
            matrix will have dimensions corresponding to the source and target 
            coordinate systems. If the input dimension is M, and the output dimension 
            is N, then the matrix will have size [M][N]. The elements of the matrix 
            {elt[n][m] : n=0..(N-1)} form a vector in the output space which is 
            parallel to the displacement caused by a small change in the m'th ordinate 
            in the input space.
            </summary>
            <param name="point"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.MathTransform.GetCodomainConvexHull(System.Collections.Generic.List{System.Double})">
            <summary>
            Gets transformed convex hull.
            </summary>
            <remarks>
            <para>The supplied ordinates are interpreted as a sequence of points, which generates a convex
            hull in the source space. The returned sequence of ordinates represents a convex hull in the 
            output space. The number of output points will often be different from the number of input 
            points. Each of the input points should be inside the valid domain (this can be checked by 
            testing the points' domain flags individually). However, the convex hull of the input points
            may go outside the valid domain. The returned convex hull should contain the transformed image
            of the intersection of the source convex hull and the source domain.</para>
            <para>A convex hull is a shape in a coordinate system, where if two positions A and B are 
            inside the shape, then all positions in the straight line between A and B are also inside 
            the shape. So in 3D a cube and a sphere are both convex hulls. Other less obvious examples 
            of convex hulls are straight lines, and single points. (A single point is a convex hull, 
            because the positions A and B must both be the same - i.e. the point itself. So the straight
            line between A and B has zero length.)</para>
            <para>Some examples of shapes that are NOT convex hulls are donuts, and horseshoes.</para>
            </remarks>
            <param name="points"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.MathTransform.GetDomainFlags(System.Collections.Generic.List{System.Double})">
            <summary>
            Gets flags classifying domain points within a convex hull.
            </summary>
            <remarks>
            The supplied ordinates are interpreted as a sequence of points, which 
            generates a convex hull in the source space. Conceptually, each of the 
            (usually infinite) points inside the convex hull is then tested against
            the source domain. The flags of all these tests are then combined. In 
            practice, implementations of different transforms will use different 
            short-cuts to avoid doing an infinite number of tests.
            </remarks>
            <param name="points"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.MathTransform.Inverse">
            <summary>
            Creates the inverse transform of this object.
            </summary>
            <remarks>This method may fail if the transform is not one to one. However, all cartographic projections should succeed.</remarks>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.MathTransform.Transform(System.Double[])">
            <summary>
            Transforms a coordinate point. The passed parameter point should not be modified.
            </summary>
            <param name="point"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.MathTransform.TransformList(System.Collections.Generic.List{System.Double[]})">
            <summary>
            Transforms a list of coordinate point ordinal values.
            </summary>
            <remarks>
            This method is provided for efficiently transforming many points. The supplied array 
            of ordinal values will contain packed ordinal values. For example, if the source 
            dimension is 3, then the ordinals will be packed in this order (x0,y0,z0,x1,y1,z1 ...).
            The size of the passed array must be an integer multiple of DimSource. The returned 
            ordinal values are packed in a similar way. In some DCPs. the ordinals may be 
            transformed in-place, and the returned array may be the same as the passed array.
            So any client code should not attempt to reuse the passed ordinal values (although
            they can certainly reuse the passed array). If there is any problem then the server
            implementation will throw an exception. If this happens then the client should not
            make any assumptions about the state of the ordinal values.
            </remarks>
            <param name="points"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.MathTransform.Invert">
            <summary>
            Reverses the transformation
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.MathTransform.Degrees2Radians(System.Double)">
            <summary>
            To convert degrees to radians, multiply degrees by pi/180. 
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.MathTransform.Radians2Degrees(System.Double)">
            <summary>
            
            </summary>
            <param name="rad"></param>
            <returns></returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.MathTransform.DimSource">
            <summary>
            Gets the dimension of input points.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.MathTransform.DimTarget">
            <summary>
            Gets the dimension of output points.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.MathTransform.WKT">
            <summary>
            Gets a Well-Known text representation of this object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.MathTransform.XML">
            <summary>
            Gets an XML representation of this object.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.GeographicTransform.Inverse">
            <summary>
            Creates the inverse transform of this object.
            </summary>
            <remarks>This method may fail if the transform is not one to one. However, all cartographic projections should succeed.</remarks>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.GeographicTransform.Transform(System.Double[])">
            <summary>
            Transforms a coordinate point. The passed parameter point should not be modified.
            </summary>
            <param name="point"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.GeographicTransform.TransformList(System.Collections.Generic.List{System.Double[]})">
            <summary>
            Transforms a list of coordinate point ordinal values.
            </summary>
            <remarks>
            This method is provided for efficiently transforming many points. The supplied array 
            of ordinal values will contain packed ordinal values. For example, if the source 
            dimension is 3, then the ordinals will be packed in this order (x0,y0,z0,x1,y1,z1 ...).
            The size of the passed array must be an integer multiple of DimSource. The returned 
            ordinal values are packed in a similar way. In some DCPs. the ordinals may be 
            transformed in-place, and the returned array may be the same as the passed array.
            So any client code should not attempt to reuse the passed ordinal values (although
            they can certainly reuse the passed array). If there is any problem then the server
            implementation will throw an exception. If this happens then the client should not
            make any assumptions about the state of the ordinal values.
            </remarks>
            <param name="points"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.GeographicTransform.Invert">
            <summary>
            Reverses the transformation
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.GeographicTransform.SourceGCS">
            <summary>
            Gets or sets the source geographic coordinate system for the transformation.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.GeographicTransform.TargetGCS">
            <summary>
            Gets or sets the target geographic coordinate system for the transformation.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.GeographicTransform.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification. [NOT IMPLEMENTED].
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.GeographicTransform.XML">
            <summary>
            Gets an XML representation of this object [NOT IMPLEMENTED].
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.ILocalCoordinateSystem">
            <summary>
            A local coordinate system, with uncertain relationship to the world.
            </summary>
            <remarks>In general, a local coordinate system cannot be related to other coordinate 
            systems. However, if two objects supporting this interface have the same dimension, 
            axes, units and datum then client code is permitted to assume that the two coordinate
            systems are identical. This allows several datasets from a common source (e.g. a CAD
            system) to be overlaid. In addition, some implementations of the Coordinate 
            Transformation (CT) package may have a mechanism for correlating local datums. (E.g. 
            from a database of transformations, which is created and maintained from real-world 
            measurements.)
            </remarks>
        </member>
        <member name="T:SharpMap.CoordinateSystems.ICoordinateSystem">
            <summary>
            Base interface for all coordinate systems
            </summary>
            <remarks>
            <para>A coordinate system is a mathematical space, where the elements of the space are called
            positions. Each position is described by a list of numbers. The length of the list corresponds
            to the dimension of the coordinate system. So in a 2D coordinate system each position is 
            described by a list containing 2 numbers.</para>
            <para>
            However, in a coordinate system, not all lists of numbers correspond to a position - 
            some lists may be outside the domain of the coordinate system. For example, in a 2D Lat/Lon
            coordinate system, the list (91,91) does not correspond to a position.</para>
            <para>
            Some coordinate systems also have a mapping from the mathematical space into locations
            in the real world. So in a Lat/Lon coordinate system, the mathematical position (lat, long) 
            corresponds to a location on the surface of the Earth. This mapping from the mathematical 
            space into real-world locations is called a Datum.</para>
            </remarks>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IInfo">
            <summary>
            The ISpatialReferenceInfo interface defines the standard 
            information stored with spatial reference objects. This
            interface is reused for many of the spatial reference
            objects in the system.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.IInfo.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IInfo.Name">
            <summary>
            Gets or sets the name of the object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IInfo.Authority">
            <summary>
            Gets or sets the authority name for this object, e.g., “POSC”,
            is this is a standard object with an authority specific
            identity code. Returns “CUSTOM” if this is a custom object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IInfo.AuthorityCode">
            <summary>
            Gets or sets the authority specific identification code of the object
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IInfo.Alias">
            <summary>
            Gets or sets the alias of the object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IInfo.Abbreviation">
            <summary>
            Gets or sets the abbreviation of the object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IInfo.Remarks">
            <summary>
            Gets or sets the provider-supplied remarks for the object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IInfo.WKT">
            <summary>
            Returns the Well-known text for this spatial reference object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IInfo.XML">
            <summary>
            Gets an XML representation of this object.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystem.GetAxis(System.Int32)">
            <summary>
            Gets axis details for dimension within coordinate system.
            </summary>
            <param name="dimension">Dimension</param>
            <returns>Axis info</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystem.GetUnits(System.Int32)">
            <summary>
            Gets units for dimension within coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ICoordinateSystem.Dimension">
            <summary>
            Dimension of the coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ICoordinateSystem.DefaultEnvelope">
            <summary>
            Gets default envelope of coordinate system.
            </summary>
            <remarks>
            Gets default envelope of coordinate system. Coordinate systems 
            which are bounded should return the minimum bounding box of their 
            domain. Unbounded coordinate systems should return a box which is 
            as large as is likely to be used. For example, a (lon,lat) 
            geographic coordinate system in degrees should return a box from 
            (-180,-90) to (180,90), and a geocentric coordinate system could 
            return a box from (-r,-r,-r) to (+r,+r,+r) where r is the 
            approximate radius of the Earth.
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ILocalCoordinateSystem.LocalDatum">
            <summary>
            Gets or sets the local datum
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Wgs84ConversionInfo">
            <summary>
            Parameters for a geographic transformation into WGS84. The Bursa Wolf parameters should be applied 
            to geocentric coordinates, where the X axis points towards the Greenwich Prime Meridian, the Y axis
            points East, and the Z axis points North.
            </summary>
            <remarks>
            <para>These parameters can be used to approximate a transformation from the horizontal datum to the
            WGS84 datum using a Bursa Wolf transformation. However, it must be remembered that this transformation
            is only an approximation. For a given horizontal datum, different Bursa Wolf transformations can be
            used to minimize the errors over different regions.</para>
            <para>If the DATUM clause contains a TOWGS84 clause, then this should be its “preferred” transformation,
            which will often be the transformation which gives a broad approximation over the whole area of interest
            (e.g. the area of interest in the containing geographic coordinate system).</para>
            <para>Sometimes, only the first three or six parameters are defined. In this case the remaining
            parameters must be zero. If only three parameters are defined, then they can still be plugged into the
            Bursa Wolf formulas, or you can take a short cut. The Bursa Wolf transformation works on geocentric
            coordinates, so you cannot apply it onto geographic coordinates directly. If there are only three
            parameters then you can use the Molodenski or abridged Molodenski formulas.</para>
            <para>If a datums ToWgs84Parameters parameter values are zero, then the receiving
            application can assume that the writing application believed that the datum is approximately equal to
            WGS84.</para>
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Wgs84ConversionInfo.#ctor">
            <summary>
            Initializes an instance of Wgs84ConversionInfo with default parameters (all values = 0)
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Wgs84ConversionInfo.#ctor(System.Double,System.Double,System.Double,System.Double,System.Double,System.Double,System.Double)">
            <summary>
            Initializes an instance of Wgs84ConversionInfo
            </summary>
            <param name="dx">Bursa Wolf shift in meters.</param>
            <param name="dy">Bursa Wolf shift in meters.</param>
            <param name="dz">Bursa Wolf shift in meters.</param>
            <param name="ex">Bursa Wolf rotation in arc seconds.</param>
            <param name="ey">Bursa Wolf rotation in arc seconds.</param>
            <param name="ez">Bursa Wolf rotation in arc seconds.</param>
            <param name="ppm">Bursa Wolf scaling in parts per million.</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Wgs84ConversionInfo.#ctor(System.Double,System.Double,System.Double,System.Double,System.Double,System.Double,System.Double,System.String)">
            <summary>
            Initializes an instance of Wgs84ConversionInfo
            </summary>
            <param name="dx">Bursa Wolf shift in meters.</param>
            <param name="dy">Bursa Wolf shift in meters.</param>
            <param name="dz">Bursa Wolf shift in meters.</param>
            <param name="ex">Bursa Wolf rotation in arc seconds.</param>
            <param name="ey">Bursa Wolf rotation in arc seconds.</param>
            <param name="ez">Bursa Wolf rotation in arc seconds.</param>
            <param name="ppm">Bursa Wolf scaling in parts per million.</param>
            <param name="areaOfUse">Area of use for this transformation</param>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Wgs84ConversionInfo.Dx">
            <summary>
            Bursa Wolf shift in meters.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Wgs84ConversionInfo.Dy">
            <summary>
            Bursa Wolf shift in meters.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Wgs84ConversionInfo.Dz">
            <summary>
            Bursa Wolf shift in meters.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Wgs84ConversionInfo.Ex">
            <summary>
            Bursa Wolf rotation in arc seconds.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Wgs84ConversionInfo.Ey">
            <summary>
            Bursa Wolf rotation in arc seconds.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Wgs84ConversionInfo.Ez">
            <summary>
            Bursa Wolf rotation in arc seconds.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Wgs84ConversionInfo.Ppm">
            <summary>
            Bursa Wolf scaling in parts per million.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Wgs84ConversionInfo.AreaOfUse">
            <summary>
            Human readable text describing intended region of transformation.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Wgs84ConversionInfo.GetAffineTransform">
            <summary>
            Affine Bursa-Wolf matrix transformation
            </summary>
            <remarks>
            <para>Transformation of coordinates from one geographic coordinate system into another 
            (also colloquially known as a "datum transformation") is usually carried out as an 
            implicit concatenation of three transformations:</para>
            <para>[geographical to geocentric >> geocentric to geocentric >> geocentric to geographic</para>
            <para>
            The middle part of the concatenated transformation, from geocentric to geocentric, is usually 
            described as a simplified 7-parameter Helmert transformation, expressed in matrix form with 7 
            parameters, in what is known as the "Bursa-Wolf" formula:<br/>
            <code>
             S = 1 + Ppm/1000000
             [ Xt ]    [     S   -Ez*S   +Ey*S   Dx ]  [ Xs ]
             [ Yt ]  = [ +Ez*S       S   -Ex*S   Dy ]  [ Ys ]
             [ Zt ]    [ -Ey*S   +Ex*S       S   Dz ]  [ Zs ]
             [ 1  ]    [     0       0       0    1 ]  [ 1  ]
            </code><br/>
            The parameters are commonly referred to defining the transformation "from source coordinate system 
            to target coordinate system", whereby (XS, YS, ZS) are the coordinates of the point in the source 
            geocentric coordinate system and (XT, YT, ZT) are the coordinates of the point in the target 
            geocentric coordinate system. But that does not define the parameters uniquely; neither is the
            definition of the parameters implied in the formula, as is often believed. However, the 
            following definition, which is consistent with the "Position Vector Transformation" convention, 
            is common E&amp;P survey practice: 
            </para>	
            <para>(dX, dY, dZ): Translation vector, to be added to the point's position vector in the source 
            coordinate system in order to transform from source system to target system; also: the coordinates 
            of the origin of source coordinate system in the target coordinate system </para>
            <para>(RX, RY, RZ): Rotations to be applied to the point's vector. The sign convention is such that 
            a positive rotation about an axis is defined as a clockwise rotation of the position vector when 
            viewed from the origin of the Cartesian coordinate system in the positive direction of that axis;
            e.g. a positive rotation about the Z-axis only from source system to target system will result in a
            larger longitude value for the point in the target system. Although rotation angles may be quoted in
            any angular unit of measure, the formula as given here requires the angles to be provided in radians.</para>
            <para>: The scale correction to be made to the position vector in the source coordinate system in order 
            to obtain the correct scale in the target coordinate system. M = (1 + dS*10-6), whereby dS is the scale
            correction expressed in parts per million.</para>
            <para><see href="http://www.posc.org/Epicentre.2_2/DataModel/ExamplesofUsage/eu_cs35.html"/> for an explanation of the Bursa-Wolf transformation</para>
            </remarks>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Wgs84ConversionInfo.ToString">
            <summary>
            Returns the Well Known Text (WKT) for this object.
            </summary>
            <remarks>The WKT format of this object is: <code>TOWGS84[dx, dy, dz, ex, ey, ez, ppm]</code></remarks>
            <returns>WKT representaion</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Wgs84ConversionInfo.Equals(System.Object)">
            <summary>
            Indicates whether the current object is equal to another object of the same type.
            </summary>
            <param name="obj"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Wgs84ConversionInfo.GetHashCode">
            <summary>
            Returns a hash code for the specified object
            </summary>
            <returns>A hash code for the specified object</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Wgs84ConversionInfo.Equals(SharpMap.CoordinateSystems.Wgs84ConversionInfo)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Wgs84ConversionInfo.WKT">
            <summary>
            Returns the Well Known Text (WKT) for this object.
            </summary>
            <remarks>The WKT format of this object is: <code>TOWGS84[dx, dy, dz, ex, ey, ez, ppm]</code></remarks>
            <returns>WKT representaion</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Wgs84ConversionInfo.XML">
            <summary>
            Gets an XML representation of this object
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Wgs84ConversionInfo.HasZeroValuesOnly">
            <summary>
            Returns true of all 7 parameter values are 0.0
            </summary>
            <returns></returns>
        </member>
        <member name="T:SharpMap.CoordinateSystems.DatumType">
            <summary>
            A vertical datum of geoid model derived heights, also called GPS-derived heights.
            These heights are approximations of orthometric heights (H), constructed from the
            ellipsoidal heights (h) by the use of the given geoid undulation model (N) through
            the equation: H=h-N.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.HD_Min">
            <summary>
            Lowest possible value for horizontal datum types
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.HD_Other">
            <summary>
            Unspecified horizontal datum type. Horizontal datums with this type should never
            supply a conversion to WGS84 using Bursa Wolf parameters.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.HD_Classic">
            <summary>
            These datums, such as ED50, NAD27 and NAD83, have been designed to support
            horizontal positions on the ellipsoid as opposed to positions in 3-D space. These datums were designed mainly to support a horizontal component of a position in a domain of limited extent, such as a country, a region or a continent.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.HD_Geocentric">
            <summary>
            A geocentric datum is a "satellite age" modern geodetic datum mainly of global
            extent, such as WGS84 (used in GPS), PZ90 (used in GLONASS) and ITRF. These
            datums were designed to support both a horizontal component of position and 
            a vertical component of position (through ellipsoidal heights). The regional
            realizations of ITRF, such as ETRF, are also included in this category.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.HD_Max">
            <summary>
            Highest possible value for horizontal datum types.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.VD_Min">
            <summary>
            Lowest possible value for vertical datum types.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.VD_Other">
            <summary>
            Unspecified vertical datum type.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.VD_Orthometric">
            <summary>
            A vertical datum for orthometric heights that are measured along the plumb line.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.VD_Ellipsoidal">
            <summary>
            A vertical datum for ellipsoidal heights that are measured along the normal to
            the ellipsoid used in the definition of horizontal datum.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.VD_AltitudeBarometric">
            <summary>
            The vertical datum of altitudes or heights in the atmosphere. These are
            approximations of orthometric heights obtained with the help of a barometer or
            a barometric altimeter. These values are usually expressed in one of the
            following units: meters, feet, millibars (used to measure pressure levels), or
            theta value (units used to measure geopotential height).
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.VD_Normal">
            <summary>
            A normal height system.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.VD_GeoidModelDerived">
            <summary>
            A vertical datum of geoid model derived heights, also called GPS-derived heights.
            These heights are approximations of orthometric heights (H), constructed from the
            ellipsoidal heights (h) by the use of the given geoid undulation model (N) 
            through the equation: H=h-N.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.VD_Depth">
            <summary>
            This attribute is used to support the set of datums generated for hydrographic
            engineering projects where depth measurements below sea level are needed. It is
            often called a hydrographic or a marine datum. Depths are measured in the 
            direction perpendicular (approximately) to the actual equipotential surfaces of
            the earth's gravity field, using such procedures as echo-sounding.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.VD_Max">
            <summary>
            Highest possible value for vertical datum types.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.LD_Min">
            <summary>
            Lowest possible value for local datum types.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.DatumType.LD_Max">
            <summary>
            Highest possible value for local datum types.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.DomainFlags">
            <summary>
            Flags indicating parts of domain covered by a convex hull. 
            </summary>
            <remarks>
            These flags can be combined. For example, the value 3 
            corresponds to a combination of <see cref="F:SharpMap.CoordinateSystems.Transformations.DomainFlags.Inside"/> and <see cref="F:SharpMap.CoordinateSystems.Transformations.DomainFlags.Outside"/>,
            which means that some parts of the convex hull are inside the 
            domain, and some parts of the convex hull are outside the domain.
            </remarks>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.DomainFlags.Inside">
            <summary>
            At least one point in a convex hull is inside the transform's domain.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.DomainFlags.Outside">
            <summary>
            At least one point in a convex hull is outside the transform's domain.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.DomainFlags.Discontinuous">
            <summary>
            At least one point in a convex hull is not transformed continuously.
            </summary>
            <remarks>
            As an example, consider a "Longitude_Rotation" transform which adjusts 
            longitude coordinates to take account of a change in Prime Meridian. If
            the rotation is 5 degrees east, then the point (Lat=175,Lon=0) is not 
            transformed continuously, since it is on the meridian line which will 
            be split at +180/-180 degrees.
            </remarks>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.CoordinateTransformation">
            <summary>
            Describes a coordinate transformation. This class only describes a 
            coordinate transformation, it does not actually perform the transform 
            operation on points. To transform points you must use a <see cref="P:SharpMap.CoordinateSystems.Transformations.CoordinateTransformation.MathTransform"/>.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation">
            <summary>
            Describes a coordinate transformation. This interface only describes a 
            coordinate transformation, it does not actually perform the transform 
            operation on points. To transform points you must use a math transform.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation.AreaOfUse">
            <summary>
            Human readable description of domain in source coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation.Authority">
            <summary>
            Authority which defined transformation and parameter values.
            </summary>
            <remarks>
            An Authority is an organization that maintains definitions of Authority Codes. For example the European Petroleum Survey Group (EPSG) maintains a database of coordinate systems, and other spatial referencing objects, where each object has a code number ID. For example, the EPSG code for a WGS84 Lat/Lon coordinate system is ‘4326’
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation.AuthorityCode">
            <summary>
            Code used by authority to identify transformation. An empty string is used for no code.
            </summary>
            <remarks>The AuthorityCode is a compact string defined by an Authority to reference a particular spatial reference object. For example, the European Survey Group (EPSG) authority uses 32 bit integers to reference coordinate systems, so all their code strings will consist of a few digits. The EPSG code for WGS84 Lat/Lon is ‘4326’.</remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation.MathTransform">
            <summary>
            Gets math transform.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation.Name">
            <summary>
            Name of transformation.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation.Remarks">
            <summary>
            Gets the provider-supplied remarks.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation.SourceCS">
            <summary>
            Source coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation.TargetCS">
            <summary>
            Target coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation.TransformType">
            <summary>
            Semantic type of transform. For example, a datum transformation or a coordinate conversion.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.CoordinateTransformation.#ctor(SharpMap.CoordinateSystems.ICoordinateSystem,SharpMap.CoordinateSystems.ICoordinateSystem,SharpMap.CoordinateSystems.Transformations.TransformType,SharpMap.CoordinateSystems.Transformations.IMathTransform,System.String,System.String,System.Int64,System.String,System.String)">
            <summary>
            Initializes an instance of a CoordinateTransformation
            </summary>
            <param name="sourceCS">Source coordinate system</param>
            <param name="targetCS">Target coordinate system</param>
            <param name="transformType">Transformation type</param>
            <param name="mathTransform">Math transform</param>
            <param name="name">Name of transform</param>
            <param name="authority">Authority</param>
            <param name="authorityCode">Authority code</param>
            <param name="areaOfUse">Area of use</param>
            <param name="remarks">Remarks</param>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.CoordinateTransformation.AreaOfUse">
            <summary>
            Human readable description of domain in source coordinate system.
            </summary>		
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.CoordinateTransformation.Authority">
            <summary>
            Authority which defined transformation and parameter values.
            </summary>
            <remarks>
            An Authority is an organization that maintains definitions of Authority Codes. For example the European Petroleum Survey Group (EPSG) maintains a database of coordinate systems, and other spatial referencing objects, where each object has a code number ID. For example, the EPSG code for a WGS84 Lat/Lon coordinate system is ‘4326’
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.CoordinateTransformation.AuthorityCode">
            <summary>
            Code used by authority to identify transformation. An empty string is used for no code.
            </summary>
            <remarks>The AuthorityCode is a compact string defined by an Authority to reference a particular spatial reference object. For example, the European Survey Group (EPSG) authority uses 32 bit integers to reference coordinate systems, so all their code strings will consist of a few digits. The EPSG code for WGS84 Lat/Lon is ‘4326’.</remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.CoordinateTransformation.MathTransform">
            <summary>
            Gets math transform.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.CoordinateTransformation.Name">
            <summary>
            Name of transformation.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.CoordinateTransformation.Remarks">
            <summary>
            Gets the provider-supplied remarks.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.CoordinateTransformation.SourceCS">
            <summary>
            Source coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.CoordinateTransformation.TargetCS">
            <summary>
            Target coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.CoordinateTransformation.TransformType">
            <summary>
            Semantic type of transform. For example, a datum transformation or a coordinate conversion.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Ellipsoid">
            <summary>
            The IEllipsoid interface defines the standard information stored with ellipsoid objects.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Info">
            <summary>
            The Info object defines the standard information
            stored with spatial reference objects
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Info.#ctor(System.String,System.String,System.Int64,System.String,System.String,System.String)">
            <summary>
            A base interface for metadata applicable to coordinate system objects.
            </summary>
            <remarks>
            <para>The metadata items ‘Abbreviation’, ‘Alias’, ‘Authority’, ‘AuthorityCode’, ‘Name’ and ‘Remarks’ 
            were specified in the Simple Features interfaces, so they have been kept here.</para>
            <para>This specification does not dictate what the contents of these items 
            should be. However, the following guidelines are suggested:</para>
            <para>When <see cref="T:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory"/> is used to create an object, the ‘Authority’
            and 'AuthorityCode' values should be set to the authority name of the factory object, and the authority 
            code supplied by the client, respectively. The other values may or may not be set. (If the authority is 
            EPSG, the implementer may consider using the corresponding metadata values in the EPSG tables.)</para>
            <para>When <see cref="T:SharpMap.CoordinateSystems.CoordinateSystemFactory"/> creates an object, the 'Name' should be set to the value
            supplied by the client. All of the other metadata items should be left empty</para>
            </remarks>
            <param name="name">Name</param>
            <param name="authority">Authority name</param>
            <param name="code">Authority-specific identification code.</param>
            <param name="alias">Alias</param>
            <param name="abbreviation">Abbreviation</param>
            <param name="remarks">Provider-supplied remarks</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Info.ToString">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Info.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Info.Name">
            <summary>
            Gets or sets the name of the object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Info.Authority">
            <summary>
            Gets or sets the authority name for this object, e.g., "EPSG",
            is this is a standard object with an authority specific
            identity code. Returns "CUSTOM" if this is a custom object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Info.AuthorityCode">
            <summary>
            Gets or sets the authority specific identification code of the object
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Info.Alias">
            <summary>
            Gets or sets the alias of the object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Info.Abbreviation">
            <summary>
            Gets or sets the abbreviation of the object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Info.Remarks">
            <summary>
            Gets or sets the provider-supplied remarks for the object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Info.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Info.XML">
            <summary>
            Gets an XML representation of this object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Info.InfoXml">
            <summary>
            Returns an XML string of the info object
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IEllipsoid">
            <summary>
            The IEllipsoid interface defines the standard information stored with ellipsoid objects.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IEllipsoid.SemiMajorAxis">
            <summary>
            Gets or sets the value of the semi-major axis.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IEllipsoid.SemiMinorAxis">
            <summary>
            Gets or sets the value of the semi-minor axis.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IEllipsoid.InverseFlattening">
            <summary>
            Gets or sets the value of the inverse of the flattening constant of the ellipsoid.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IEllipsoid.AxisUnit">
            <summary>
            Gets or sets the value of the axis unit.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IEllipsoid.IsIvfDefinitive">
            <summary>
            Is the Inverse Flattening definitive for this ellipsoid? Some ellipsoids use the
            IVF as the defining value, and calculate the polar radius whenever asked. Other
            ellipsoids use the polar radius to calculate the IVF whenever asked. This
            distinction can be important to avoid floating-point rounding errors.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Ellipsoid.#ctor(System.Double,System.Double,System.Double,System.Boolean,SharpMap.CoordinateSystems.ILinearUnit,System.String,System.String,System.Int64,System.String,System.String,System.String)">
            <summary>
            Initializes a new instance of an Ellipsoid
            </summary>
            <param name="semiMajorAxis">Semi major axis</param>
            <param name="semiMinorAxis">Semi minor axis</param>
            <param name="inverseFlattening">Inverse flattening</param>
            <param name="isIvfDefinitive">Inverse Flattening is definitive for this ellipsoid (Semi-minor axis will be overridden)</param>
            <param name="axisUnit">Axis unit</param>
            <param name="name">Name</param>
            <param name="authority">Authority name</param>
            <param name="code">Authority-specific identification code.</param>
            <param name="alias">Alias</param>
            <param name="abbreviation">Abbreviation</param>
            <param name="remarks">Provider-supplied remarks</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Ellipsoid.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.WGS84">
            <summary>
            WGS 84 ellipsoid
            </summary>
            <remarks>
            Inverse flattening derived from four defining parameters 
            (semi-major axis;
            C20 = -484.16685*10e-6;
            earth's angular velocity w = 7292115e11 rad/sec;
            gravitational constant GM = 3986005e8 m*m*m/s/s).
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.WGS72">
            <summary>
            WGS 72 Ellipsoid
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.GRS80">
            <summary>
            GRS 1980 / International 1979 ellipsoid
            </summary>
            <remarks>
            Adopted by IUGG 1979 Canberra.
            Inverse flattening is derived from
            geocentric gravitational constant GM = 3986005e8 m*m*m/s/s;
            dynamic form factor J2 = 108263e8 and Earth's angular velocity = 7292115e-11 rad/s.")
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.International1924">
            <summary>
            International 1924 / Hayford 1909 ellipsoid
            </summary>
            <remarks>
            Described as a=6378388 m. and b=6356909m. from which 1/f derived to be 296.95926. 
            The figure was adopted as the International ellipsoid in 1924 but with 1/f taken as
            297 exactly from which b is derived as 6356911.946m.
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.Clarke1880">
            <summary>
            Clarke 1880
            </summary>
            <remarks>
            Clarke gave a and b and also 1/f=293.465 (to 3 decimal places).  1/f derived from a and b = 293.4663077
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.Clarke1866">
            <summary>
            Clarke 1866
            </summary>
            <remarks>
            Original definition a=20926062 and b=20855121 (British) feet. Uses Clarke's 1865 inch-metre ratio of 39.370432 to obtain metres. (Metric value then converted to US survey feet for use in the United States using 39.37 exactly giving a=20925832.16 ft US).
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.Sphere">
            <summary>
            Sphere
            </summary>
            <remarks>
            Authalic sphere derived from GRS 1980 ellipsoid (code 7019).  (An authalic sphere is
            one with a surface area equal to the surface area of the ellipsoid). 1/f is infinite.
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.SemiMajorAxis">
            <summary>
            Gets or sets the value of the semi-major axis.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.SemiMinorAxis">
            <summary>
            Gets or sets the value of the semi-minor axis.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.InverseFlattening">
            <summary>
            Gets or sets the value of the inverse of the flattening constant of the ellipsoid.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.AxisUnit">
            <summary>
            Gets or sets the value of the axis unit.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.IsIvfDefinitive">
            <summary>
            Tells if the Inverse Flattening is definitive for this ellipsoid. Some ellipsoids use 
            the IVF as the defining value, and calculate the polar radius whenever asked. Other
            ellipsoids use the polar radius to calculate the IVF whenever asked. This 
            distinction can be important to avoid floating-point rounding errors.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Ellipsoid.XML">
            <summary>
            Gets an XML representation of this object
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.DatumTransform">
            <summary>
            Transformation for applying 
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.DatumTransform.#ctor(SharpMap.CoordinateSystems.Wgs84ConversionInfo)">
            <summary>
            Initializes a new instance of the <see cref="T:SharpMap.CoordinateSystems.Transformations.DatumTransform"/> class.
            </summary>
            <param name="towgs84"></param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.DatumTransform.Inverse">
            <summary>
            Creates the inverse transform of this object.
            </summary>
            <returns></returns>
            <remarks>This method may fail if the transform is not one to one. However, all cartographic projections should succeed.</remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.DatumTransform.Transform(System.Double[])">
            <summary>
            Transforms a coordinate point. The passed parameter point should not be modified.
            </summary>
            <param name="point"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.DatumTransform.TransformList(System.Collections.Generic.List{System.Double[]})">
            <summary>
            Transforms a list of coordinate point ordinal values.
            </summary>
            <param name="points"></param>
            <returns></returns>
            <remarks>
            This method is provided for efficiently transforming many points. The supplied array
            of ordinal values will contain packed ordinal values. For example, if the source
            dimension is 3, then the ordinals will be packed in this order (x0,y0,z0,x1,y1,z1 ...).
            The size of the passed array must be an integer multiple of DimSource. The returned
            ordinal values are packed in a similar way. In some DCPs. the ordinals may be
            transformed in-place, and the returned array may be the same as the passed array.
            So any client code should not attempt to reuse the passed ordinal values (although
            they can certainly reuse the passed array). If there is any problem then the server
            implementation will throw an exception. If this happens then the client should not
            make any assumptions about the state of the ordinal values.
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.DatumTransform.Invert">
            <summary>
            Reverses the transformation
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.DatumTransform.WKT">
            <summary>
            Gets a Well-Known text representation of this object.
            </summary>
            <value></value>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.DatumTransform.XML">
            <summary>
            Gets an XML representation of this object.
            </summary>
            <value></value>
        </member>
        <member name="T:SharpMap.CoordinateSystems.ProjectionParameter">
            <summary>
            A named projection parameter value.
            </summary>
            <remarks>
            The linear units of parameters' values match the linear units of the containing 
            projected coordinate system. The angular units of parameter values match the 
            angular units of the geographic coordinate system that the projected coordinate 
            system is based on. (Notice that this is different from <see cref="T:SharpMap.CoordinateSystems.Parameter"/>,
            where the units are always meters and degrees.)
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ProjectionParameter.#ctor(System.String,System.Double)">
            <summary>
            Initializes an instance of a ProjectionParameter
            </summary>
            <param name="name">Name of parameter</param>
            <param name="value">Parameter value</param>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ProjectionParameter.Name">
            <summary>
            Parameter name.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ProjectionParameter.Value">
            <summary>
            Parameter value.
            The linear units of a parameters' values match the linear units of the containing 
            projected coordinate system. The angular units of parameter values match the 
            angular units of the geographic coordinate system that the projected coordinate 
            system is based on.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ProjectionParameter.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ProjectionParameter.XML">
            <summary>
            Gets an XML representation of this object
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Parameter">
            <summary>
            A named parameter value.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Parameter.#ctor(System.String,System.Double)">
            <summary>
            Creates an instance of a parameter
            </summary>
            <remarks>Units are always either meters or degrees.</remarks>
            <param name="name">Name of parameter</param>
            <param name="value">Value</param>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Parameter.Name">
            <summary>
            Parameter name
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Parameter.Value">
            <summary>
            Parameter value
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IVerticalDatum">
            <summary>
            Procedure used to measure vertical distances.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IDatum">
            <summary>
            A set of quantities from which other quantities are calculated.
            </summary>
            <remarks>
            For the OGC abstract model, it can be defined as a set of real points on the earth 
            that have coordinates. EG. A datum can be thought of as a set of parameters 
            defining completely the origin and orientation of a coordinate system with respect 
            to the earth. A textual description and/or a set of parameters describing the 
            relationship of a coordinate system to some predefined physical locations (such 
            as center of mass) and physical directions (such as axis of spin). The definition 
            of the datum may also include the temporal behavior (such as the rate of change of
            the orientation of the coordinate axes).
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IDatum.DatumType">
            <summary>
            Gets or sets the type of the datum as an enumerated code.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.GeographicTransform">
            <summary>
            The GeographicTransform class is implemented on geographic transformation objects and
            implements datum transformations between geographic coordinate systems.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IGeographicTransform">
            <summary>
            The IGeographicTransform interface is implemented on geographic transformation
            objects and implements datum transformations between geographic coordinate systems.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.IGeographicTransform.Forward(System.Collections.Generic.List{System.Double[]})">
            <summary>
            Transforms an array of points from the source geographic coordinate system
            to the target geographic coordinate system.
            </summary>
            <param name="points">Points in the source geographic coordinate system</param>
            <returns>Points in the target geographic coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.IGeographicTransform.Inverse(System.Collections.Generic.List{System.Double[]})">
            <summary>
            Transforms an array of points from the target geographic coordinate system
            to the source geographic coordinate system.
            </summary>
            <param name="points">Points in the target geographic coordinate system</param>
            <returns>Points in the source geographic coordinate system</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IGeographicTransform.SourceGCS">
            <summary>
            Gets or sets source geographic coordinate system for the transformation.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IGeographicTransform.TargetGCS">
            <summary>
            Gets or sets the target geographic coordinate system for the transformation.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IGeographicTransform.ParameterInfo">
            <summary>
            Returns an accessor interface to the parameters for this geographic transformation.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.GeographicTransform.Forward(System.Collections.Generic.List{System.Double[]})">
            <summary>
            Transforms an array of points from the source geographic coordinate
            system to the target geographic coordinate system.
            </summary>
            <param name="points">On input points in the source geographic coordinate system</param>
            <returns>Output points in the target geographic coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.GeographicTransform.Inverse(System.Collections.Generic.List{System.Double[]})">
            <summary>
            Transforms an array of points from the target geographic coordinate
            system to the source geographic coordinate system.
            </summary>
            <param name="points">Input points in the target geographic coordinate system,</param>
            <returns>Output points in the source geographic coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.GeographicTransform.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeographicTransform.SourceGCS">
            <summary>
            Gets or sets the source geographic coordinate system for the transformation.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeographicTransform.TargetGCS">
            <summary>
            Gets or sets the target geographic coordinate system for the transformation.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeographicTransform.ParameterInfo">
            <summary>
            Returns an accessor interface to the parameters for this geographic transformation.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeographicTransform.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeographicTransform.XML">
            <summary>
            Gets an XML representation of this object [NOT IMPLEMENTED].
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.CoordinateSystem">
            <summary>
            Base interface for all coordinate systems.
            </summary>
            <remarks>
            <para>A coordinate system is a mathematical space, where the elements of the space
            are called positions. Each position is described by a list of numbers. The length 
            of the list corresponds to the dimension of the coordinate system. So in a 2D 
            coordinate system each position is described by a list containing 2 numbers.</para>
            <para>However, in a coordinate system, not all lists of numbers correspond to a 
            position - some lists may be outside the domain of the coordinate system. For 
            example, in a 2D Lat/Lon coordinate system, the list (91,91) does not correspond
            to a position.</para>
            <para>Some coordinate systems also have a mapping from the mathematical space into 
            locations in the real world. So in a Lat/Lon coordinate system, the mathematical 
            position (lat, long) corresponds to a location on the surface of the Earth. This 
            mapping from the mathematical space into real-world locations is called a Datum.</para>
            </remarks>		
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystem.#ctor(System.String,System.String,System.Int64,System.String,System.String,System.String)">
            <summary>
            Initializes a new instance of a coordinate system.
            </summary>
            <param name="name">Name</param>
            <param name="authority">Authority name</param>
            <param name="authorityCode">Authority-specific identification code.</param>
            <param name="alias">Alias</param>
            <param name="abbreviation">Abbreviation</param>
            <param name="remarks">Provider-supplied remarks</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystem.GetUnits(System.Int32)">
            <summary>
            Gets the units for the dimension within coordinate system. 
            Each dimension in the coordinate system has corresponding units.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystem.GetAxis(System.Int32)">
            <summary>
            Gets axis details for dimension within coordinate system.
            </summary>
            <param name="dimension">Dimension</param>
            <returns>Axis info</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.CoordinateSystem.Dimension">
            <summary>
            Dimension of the coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.CoordinateSystem.DefaultEnvelope">
            <summary>
            Gets default envelope of coordinate system.
            </summary>
            <remarks>
            Coordinate systems which are bounded should return the minimum bounding box of their domain. 
            Unbounded coordinate systems should return a box which is as large as is likely to be used. 
            For example, a (lon,lat) geographic coordinate system in degrees should return a box from 
            (-180,-90) to (180,90), and a geocentric coordinate system could return a box from (-r,-r,-r)
            to (+r,+r,+r) where r is the approximate radius of the Earth.
            </remarks>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Projection">
            <summary>
            The Projection class defines the standard information stored with a projection
            objects. A projection object implements a coordinate transformation from a geographic
            coordinate system to a projected coordinate system, given the ellipsoid for the
            geographic coordinate system. It is expected that each coordinate transformation of
            interest, e.g., Transverse Mercator, Lambert, will be implemented as a class of
            type Projection, supporting the IProjection interface.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IProjection">
            <summary>
            The IProjection interface defines the standard information stored with projection
            objects. A projection object implements a coordinate transformation from a geographic
            coordinate system to a projected coordinate system, given the ellipsoid for the
            geographic coordinate system. It is expected that each coordinate transformation of
            interest, e.g., Transverse Mercator, Lambert, will be implemented as a COM class of
            coType Projection, supporting the IProjection interface.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.IProjection.GetParameter(System.Int32)">
            <summary>
            Gets an indexed parameter of the projection.
            </summary>
            <param name="n">Index of parameter</param>
            <returns>n'th parameter</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.IProjection.GetParameter(System.String)">
            <summary>
            Gets an named parameter of the projection.
            </summary>
            <remarks>The parameter name is case insensitive</remarks>
            <param name="name">Name of parameter</param>
            <returns>parameter or null if not found</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IProjection.NumParameters">
            <summary>
            Gets number of parameters of the projection.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IProjection.ClassName">
            <summary>
            Gets the projection classification name (e.g. 'Transverse_Mercator').
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projection.GetParameter(System.Int32)">
            <summary>
            Gets an indexed parameter of the projection.
            </summary>
            <param name="n">Index of parameter</param>
            <returns>n'th parameter</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projection.GetParameter(System.String)">
            <summary>
            Gets an named parameter of the projection.
            </summary>
            <remarks>The parameter name is case insensitive</remarks>
            <param name="name">Name of parameter</param>
            <returns>parameter or null if not found</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projection.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projection.NumParameters">
            <summary>
            Gets the number of parameters of the projection.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projection.Parameters">
            <summary>
            Gets or sets the parameters of the projection
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projection.ClassName">
            <summary>
            Gets the projection classification name (e.g. "Transverse_Mercator").
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projection.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projection.XML">
            <summary>
            Gets an XML representation of this object
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.ProjectedCoordinateSystem">
            <summary>
            A 2D cartographic coordinate system.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.HorizontalCoordinateSystem">
            <summary>
            A 2D coordinate system suitable for positions on the Earth's surface.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IHorizontalCoordinateSystem">
            <summary>
            A 2D coordinate system suitable for positions on the Earth's surface.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IHorizontalCoordinateSystem.HorizontalDatum">
            <summary>
            Returns the HorizontalDatum.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.HorizontalCoordinateSystem.#ctor(SharpMap.CoordinateSystems.IHorizontalDatum,System.Collections.Generic.List{SharpMap.CoordinateSystems.AxisInfo},System.String,System.String,System.Int64,System.String,System.String,System.String)">
            <summary>
            Creates an instance of HorizontalCoordinateSystem
            </summary>
            <param name="datum">Horizontal datum</param>
            <param name="axisInfo">Axis information</param>
            <param name="name">Name</param>
            <param name="authority">Authority name</param>
            <param name="code">Authority-specific identification code.</param>
            <param name="alias">Alias</param>
            <param name="abbreviation">Abbreviation</param>
            <param name="remarks">Provider-supplied remarks</param>
        </member>
        <member name="P:SharpMap.CoordinateSystems.HorizontalCoordinateSystem.HorizontalDatum">
            <summary>
            Gets or sets the HorizontalDatum.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IProjectedCoordinateSystem">
            <summary>
            The IProjectedCoordinateSystem interface defines the standard information stored with
            projected coordinate system objects. A projected coordinate system is defined using a
            geographic coordinate system object and a projection object that defines the
            coordinate transformation from the geographic coordinate system to the projected
            coordinate systems. The instances of a single ProjectedCoordinateSystem COM class can
            be used to model different projected coordinate systems (e.g., UTM Zone 10, Albers)
            by associating the ProjectedCoordinateSystem instances with Projection instances
            belonging to different Projection COM classes (Transverse Mercator and Albers,
            respectively).
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IProjectedCoordinateSystem.GeographicCoordinateSystem">
            <summary>
            Gets or sets the geographic coordinate system associated with the projected
            coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IProjectedCoordinateSystem.LinearUnit">
            <summary>
            Gets or sets the linear (projected) units of the projected coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IProjectedCoordinateSystem.Projection">
            <summary>
            Gets or sets the projection for the projected coordinate system.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ProjectedCoordinateSystem.#ctor(SharpMap.CoordinateSystems.IHorizontalDatum,SharpMap.CoordinateSystems.IGeographicCoordinateSystem,SharpMap.CoordinateSystems.ILinearUnit,SharpMap.CoordinateSystems.IProjection,System.Collections.Generic.List{SharpMap.CoordinateSystems.AxisInfo},System.String,System.String,System.Int64,System.String,System.String,System.String)">
            <summary>
            Initializes a new instance of a projected coordinate system
            </summary>
            <param name="datum">Horizontal datum</param>
            <param name="geographicCoordinateSystem">Geographic coordinate system</param>
            <param name="linearUnit">Linear unit</param>
            <param name="projection">Projection</param>
            <param name="axisInfo">Axis info</param>
            <param name="name">Name</param>
            <param name="authority">Authority name</param>
            <param name="code">Authority-specific identification code.</param>
            <param name="alias">Alias</param>
            <param name="abbreviation">Abbreviation</param>
            <param name="remarks">Provider-supplied remarks</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ProjectedCoordinateSystem.GetUnits(System.Int32)">
            <summary>
            Gets units for dimension within coordinate system. Each dimension in 
            the coordinate system has corresponding units.
            </summary>
            <param name="dimension">Dimension</param>
            <returns>Unit</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ProjectedCoordinateSystem.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ProjectedCoordinateSystem.GeographicCoordinateSystem">
            <summary>
            Gets or sets the GeographicCoordinateSystem.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ProjectedCoordinateSystem.LinearUnit">
            <summary>
            Gets or sets the <see cref="P:SharpMap.CoordinateSystems.ProjectedCoordinateSystem.LinearUnit">LinearUnits</see>. The linear unit must be the same as the <see cref="T:SharpMap.CoordinateSystems.CoordinateSystem"/> units.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ProjectedCoordinateSystem.Projection">
            <summary>
            Gets or sets the projection
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ProjectedCoordinateSystem.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ProjectedCoordinateSystem.XML">
            <summary>
            Gets an XML representation of this object.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IPrimeMeridian">
            <summary>
            The IPrimeMeridian interface defines the standard information stored with prime
            meridian objects. Any prime meridian object must implement this interface as
            well as the ISpatialReferenceInfo interface.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IPrimeMeridian.Longitude">
            <summary>
            Gets or sets the longitude of the prime meridian (relative to the Greenwich prime meridian).
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IPrimeMeridian.AngularUnit">
            <summary>
            Gets or sets the AngularUnits.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.GeocentricTransform">
            <summary>
            
            </summary>
            <remarks>
            <para>Latitude, Longitude and ellipsoidal height in terms of a 3-dimensional geographic system
            may by expressed in terms of a geocentric (earth centered) Cartesian coordinate reference system
            X, Y, Z with the Z axis corresponding to the earth's rotation axis positive northwards, the X
            axis through the intersection of the prime meridian and equator, and the Y axis through
            the intersection of the equator with longitude 90 degrees east. The geographic and geocentric
            systems are based on the same geodetic datum.</para>
            <para>Geocentric coordinate reference systems are conventionally taken to be defined with the X
            axis through the intersection of the Greenwich meridian and equator. This requires that the equivalent
            geographic coordinate reference systems based on a non-Greenwich prime meridian should first be
            transformed to their Greenwich equivalent. Geocentric coordinates X, Y and Z take their units from
            the units of the ellipsoid axes (a and b). As it is conventional for X, Y and Z to be in metres,
            if the ellipsoid axis dimensions are given in another linear unit they should first be converted
            to metres.</para>
            </remarks>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.GeocentricTransform._isInverse">
            <summary>
            
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.GeocentricTransform._Parameters">
            <summary>
            
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.GeocentricTransform._inverse">
            <summary>
            
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.GeocentricTransform.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter},System.Boolean)">
            <summary>
            Initializes a geocentric projection object
            </summary>
            <param name="parameters">List of parameters to initialize the projection.</param>
            <param name="isInverse">Indicates whether the projection forward (meters to degrees or degrees to meters).</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.GeocentricTransform.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter})">
            <summary>
            Initializes a geocentric projection object
            </summary>
            <param name="parameters">List of parameters to initialize the projection.</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.GeocentricTransform.Inverse">
            <summary>
            Returns the inverse of this conversion.
            </summary>
            <returns>IMathTransform that is the reverse of the current conversion.</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.GeocentricTransform.DegreesToMeters(System.Double[])">
            <summary>
            Converts coordinates in decimal degrees to projected meters.
            </summary>
            <param name="lonlat">The point in decimal degrees.</param>
            <returns>Point in projected meters</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.GeocentricTransform.MetersToDegrees(System.Double[])">
            <summary>
            Converts coordinates in projected meters to decimal degrees.
            </summary>
            <param name="pnt">Point in meters</param>
            <returns>Transformed point in decimal degrees</returns>		
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.GeocentricTransform.Transform(System.Double[])">
            <summary>
            Transforms a coordinate point. The passed parameter point should not be modified.
            </summary>
            <param name="point"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.GeocentricTransform.TransformList(System.Collections.Generic.List{System.Double[]})">
            <summary>
            Transforms a list of coordinate point ordinal values.
            </summary>
            <param name="points"></param>
            <returns></returns>
            <remarks>
            This method is provided for efficiently transforming many points. The supplied array
            of ordinal values will contain packed ordinal values. For example, if the source
            dimension is 3, then the ordinals will be packed in this order (x0,y0,z0,x1,y1,z1 ...).
            The size of the passed array must be an integer multiple of DimSource. The returned
            ordinal values are packed in a similar way. In some DCPs. the ordinals may be
            transformed in-place, and the returned array may be the same as the passed array.
            So any client code should not attempt to reuse the passed ordinal values (although
            they can certainly reuse the passed array). If there is any problem then the server
            implementation will throw an exception. If this happens then the client should not
            make any assumptions about the state of the ordinal values.
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.GeocentricTransform.Invert">
            <summary>
            Reverses the transformation
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.GeocentricTransform.WKT">
            <summary>
            Gets a Well-Known text representation of this object.
            </summary>
            <value></value>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.GeocentricTransform.XML">
            <summary>
            Gets an XML representation of this object.
            </summary>
            <value></value>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Projections.MapProjection">
            <summary>
            Projections inherit from this abstract class to get access to useful mathematical functions.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Projections.MapProjection.PI">
            <summary>
            PI
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Projections.MapProjection.HALF_PI">
            <summary>
            Half of PI
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Projections.MapProjection.TWO_PI">
            <summary>
            PI * 2
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Projections.MapProjection.EPSLN">
            <summary>
            EPSLN
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Projections.MapProjection.S2R">
            <summary>
            S2R
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Projections.MapProjection.MAX_VAL">
            <summary>
            MAX_VAL
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Projections.MapProjection.prjMAXLONG">
            <summary>
            prjMAXLONG
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Projections.MapProjection.DBLLONG">
            <summary>
            DBLLONG
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter},System.Boolean)">
            <summary>
            
            </summary>
            <param name="parameters"></param>
            <param name="isInverse"></param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter})">
            <summary>
            
            </summary>
            <param name="parameters"></param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.GetParameter(System.Int32)">
            <summary>
            
            </summary>
            <param name="Index"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.GetParameter(System.String)">
            <summary>
            Gets an named parameter of the projection.
            </summary>
            <remarks>The parameter name is case insensitive</remarks>
            <param name="name">Name of parameter</param>
            <returns>parameter or null if not found</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.Invert">
            <summary>
            Reverses the transformation
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.Transform(System.Double[])">
            <summary>
            Transforms the specified cp.
            </summary>
            <param name="cp">The cp.</param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.TransformList(System.Collections.Generic.List{System.Double[]})">
            <summary>
            
            </summary>
            <param name="ord"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.CUBE(System.Double)">
            <summary>
            Returns the cube of a number.
            </summary>
            <param name="x"> </param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.QUAD(System.Double)">
            <summary>
            Returns the quad of a number.
            </summary>
            <param name="x"> </param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.GMAX(System.Double@,System.Double@)">
            <summary>
            
            </summary>
            <param name="A"></param>
            <param name="B"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.GMIN(System.Double@,System.Double@)">
            <summary>
            
            </summary>
            <param name="A"></param>
            <param name="B"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.IMOD(System.Double,System.Double)">
            <summary>
            IMOD
            </summary>
            <param name="A"></param>
            <param name="B"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.sign(System.Double)">
            <summary>
            Function to return the sign of an argument
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.adjust_lon(System.Double)">
            <summary>
            
            </summary>
            <param name="x"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.msfnz(System.Double,System.Double,System.Double)">
            <summary>
            Function to compute the constant small m which is the radius of
            a parallel of latitude, phi, divided by the semimajor axis.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.qsfnz(System.Double,System.Double)">
            <summary>
            Function to compute constant small q which is the radius of a 
            parallel of latitude, phi, divided by the semimajor axis. 
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.sincos(System.Double,System.Double@,System.Double@)">
            <summary>
            Function to calculate the sine and cosine in one call.  Some computer
            systems have implemented this function, resulting in a faster implementation
            than calling each function separately.  It is provided here for those
            computer systems which don`t implement this function
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.tsfnz(System.Double,System.Double,System.Double)">
            <summary>
            Function to compute the constant small t for use in the forward
            computations in the Lambert Conformal Conic and the Polar
            Stereographic projections.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.phi1z(System.Double,System.Double,System.Int64@)">
            <summary>
            
            
            </summary>
            <param name="eccent"></param>
            <param name="qs"></param>
            <param name="flag"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.asinz(System.Double)">
            <summary>
            Function to eliminate roundoff errors in asin
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.phi2z(System.Double,System.Double,System.Int64@)">
            <summary>
            Function to compute the latitude angle, phi2, for the inverse of the
            Lambert Conformal Conic and Polar Stereographic projections.
            </summary>
            <param name="eccent">Spheroid eccentricity</param>
            <param name="ts">Constant value t</param>
            <param name="flag">Error flag number</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.e0fn(System.Double)">
            <summary>
            Functions to compute the constants e0, e1, e2, and e3 which are used
            in a series for calculating the distance along a meridian.  The
            input x represents the eccentricity squared.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.e1fn(System.Double)">
            <summary>
            
            </summary>
            <param name="x"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.e2fn(System.Double)">
            <summary>
            
            </summary>
            <param name="x"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.e3fn(System.Double)">
            <summary>
            
            </summary>
            <param name="x"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.e4fn(System.Double)">
            <summary>
            Function to compute the constant e4 from the input of the eccentricity
            of the spheroid, x.  This constant is used in the Polar Stereographic
            projection.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.mlfn(System.Double,System.Double,System.Double,System.Double,System.Double)">
            <summary>
            Function computes the value of M which is the distance along a meridian
            from the Equator to latitude phi.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.calc_utm_zone(System.Double)">
            <summary>
            Function to calculate UTM zone number--NOTE Longitude entered in DEGREES!!!
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.LongitudeToRadians(System.Double,System.Boolean)">
            <summary>
            Converts a longitude value in degrees to radians.
            </summary>
            <param name="x">The value in degrees to convert to radians.</param>
            <param name="edge">If true, -180 and +180 are valid, otherwise they are considered out of range.</param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.MapProjection.LatitudeToRadians(System.Double,System.Boolean)">
            <summary>
            Converts a latitude value in degrees to radians.
            </summary>
            <param name="y">The value in degrees to to radians.</param>
            <param name="edge">If true, -90 and +90 are valid, otherwise they are considered out of range.</param>
            <returns></returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projections.MapProjection.NumParameters">
            <summary>
            
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projections.MapProjection.ClassName">
            <summary>
            
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projections.MapProjection.Abbreviation">
            <summary>
            Gets or sets the abbreviation of the object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projections.MapProjection.Alias">
            <summary>
            Gets or sets the alias of the object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projections.MapProjection.Authority">
            <summary>
            Gets or sets the authority name for this object, e.g., "EPSG",
            is this is a standard object with an authority specific
            identity code. Returns "CUSTOM" if this is a custom object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projections.MapProjection.AuthorityCode">
            <summary>
            Gets or sets the authority specific identification code of the object
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projections.MapProjection.Name">
            <summary>
            Gets or sets the name of the object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projections.MapProjection.Remarks">
            <summary>
            Gets or sets the provider-supplied remarks for the object.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projections.MapProjection.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projections.MapProjection.XML">
            <summary>
            Gets an XML representation of this object
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Projections.MapProjection.IsInverse">
            <summary>
            Returns true if this projection is inverted.
            Most map projections define forward projection as "from geographic to projection", and backwards
            as "from projection to geographic". If this projection is inverted, this will be the other way around.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.LinearUnit">
            <summary>
            Definition of linear units.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.ILinearUnit">
            <summary>
            The ILinearUnit interface defines methods on linear units.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IUnit">
            <summary>
            The IUnit interface abstracts different kinds of units, it has no methods.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ILinearUnit.MetersPerUnit">
            <summary>
            Gets or sets the number of meters per <see cref="T:SharpMap.CoordinateSystems.ILinearUnit"/>.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.LinearUnit.#ctor(System.Double,System.String,System.String,System.Int64,System.String,System.String,System.String)">
            <summary>
            Creates an instance of a linear unit
            </summary>
            <param name="metersPerUnit">Number of meters per <see cref="T:SharpMap.CoordinateSystems.LinearUnit"/></param>
            <param name="name">Name</param>
            <param name="authority">Authority name</param>
            <param name="authorityCode">Authority-specific identification code.</param>
            <param name="alias">Alias</param>
            <param name="abbreviation">Abbreviation</param>
            <param name="remarks">Provider-supplied remarks</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.LinearUnit.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.LinearUnit.Metre">
            <summary>
            Returns the meters linear unit.
            Also known as International metre. SI standard unit.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.LinearUnit.Foot">
            <summary>
            Returns the foot linear unit (1ft = 0.3048m).
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.LinearUnit.USSurveyFoot">
            <summary>
            Returns the US Survey foot linear unit (1ftUS = 0.304800609601219m).
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.LinearUnit.NauticalMile">
            <summary>
            Returns the Nautical Mile linear unit (1NM = 1852m).
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.LinearUnit.ClarkesFoot">
            <summary>
            Returns Clarke's foot.
            </summary>
            <remarks>
            Assumes Clarke's 1865 ratio of 1 British foot = 0.3047972654 French legal metres applies to the international metre. 
            Used in older Australian, southern African &amp; British West Indian mapping.
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.LinearUnit.MetersPerUnit">
            <summary>
            Gets or sets the number of meters per <see cref="T:SharpMap.CoordinateSystems.LinearUnit"/>.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.LinearUnit.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.LinearUnit.XML">
            <summary>
            Gets an XML representation of this object
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IGeodeticSpatialReference">
            <summary>
            The IGeodeticSpatialReference interface defines a root interface for all types of geodetic
            spatial references, it is a subclass of ICoordinateSystem.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IAngularUnit">
            <summary>
            The IAngularUnit interface defines methods on angular units.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IAngularUnit.RadiansPerUnit">
            <summary>
            Gets or sets the number of radians per angular unit.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.AxisOrientationEnum">
            <summary>
            Orientation of axis. Some coordinate systems use non-standard orientations. 
            For example, the first axis in South African grids usually points West, 
            instead of East. This information is obviously relevant for algorithms
            converting South African grid coordinates into Lat/Long.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.AxisOrientationEnum.Other">
            <summary>
            Unknown or unspecified axis orientation. This can be used for local or fitted coordinate systems.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.AxisOrientationEnum.North">
            <summary>
            Increasing ordinates values go North. This is usually used for Grid Y coordinates and Latitude.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.AxisOrientationEnum.South">
            <summary>
            Increasing ordinates values go South. This is rarely used.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.AxisOrientationEnum.East">
            <summary>
            Increasing ordinates values go East. This is rarely used.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.AxisOrientationEnum.West">
            <summary>
            Increasing ordinates values go West. This is usually used for Grid X coordinates and Longitude.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.AxisOrientationEnum.Up">
            <summary>
            Increasing ordinates values go up. This is used for vertical coordinate systems.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.AxisOrientationEnum.Down">
            <summary>
            Increasing ordinates values go down. This is used for vertical coordinate systems.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.AxisInfo">
            <summary>
            Details of axis. This is used to label axes, and indicate the orientation.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.AxisInfo.#ctor(System.String,SharpMap.CoordinateSystems.AxisOrientationEnum)">
            <summary>
            Initializes a new instance of an AxisInfo.
            </summary>
            <param name="name">Name of axis</param>
            <param name="orientation">Axis orientation</param>
        </member>
        <member name="P:SharpMap.CoordinateSystems.AxisInfo.Name">
            <summary>
            Human readable name for axis. Possible values are X, Y, Long, Lat or any other short string.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.AxisInfo.Orientation">
            <summary>
            Gets enumerated value for orientation.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.AxisInfo.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.AxisInfo.XML">
            <summary>
            Gets an XML representation of this object
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformationFactory">
            <summary>
            Creates coordinate transformations.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.ICoordinateTransformationFactory.CreateFromCoordinateSystems(SharpMap.CoordinateSystems.ICoordinateSystem,SharpMap.CoordinateSystems.ICoordinateSystem)">
            <summary>
            Creates a transformation between two coordinate systems.
            </summary>
            <remarks>
            This method will examine the coordinate systems in order to construct
            a transformation between them. This method may fail if no path between 
            the coordinate systems is found, using the normal failing behavior of 
            the DCP (e.g. throwing an exception).</remarks>
            <param name="sourceCS">Source coordinate system</param>
            <param name="targetCS">Target coordinate system</param>
            <returns></returns>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Projections.AlbersProjection">
            <summary>
            	Implements the Albers projection.
            </summary>
            <remarks>
            	<para>Implements the Albers projection. The Albers projection is most commonly
            	used to project the United States of America. It gives the northern
            	border with Canada a curved appearance.</para>
            	
            	<para>The <a href="http://www.geog.mcgill.ca/courses/geo201/mapproj/naaeana.gif">Albers Equal Area</a>
            	projection has the property that the area bounded
            	by any pair of parallels and meridians is exactly reproduced between the 
            	image of those parallels and meridians in the projected domain, that is,
            	the projection preserves the correct area of the earth though distorts
            	direction, distance and shape somewhat.</para>
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.AlbersProjection.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter})">
            <summary>
            Creates an instance of an Albers projection object.
            </summary>
            <param name="parameters">List of parameters to initialize the projection.</param>
            <remarks>
            <para>The parameters this projection expects are listed below.</para>
            <list type="table">
            <listheader><term>Items</term><description>Descriptions</description></listheader>
            <item><term>latitude_of_false_origin</term><description>The latitude of the point which is not the natural origin and at which grid coordinate values false easting and false northing are defined.</description></item>
            <item><term>longitude_of_false_origin</term><description>The longitude of the point which is not the natural origin and at which grid coordinate values false easting and false northing are defined.</description></item>
            <item><term>latitude_of_1st_standard_parallel</term><description>For a conic projection with two standard parallels, this is the latitude of intersection of the cone with the ellipsoid that is nearest the pole.  Scale is true along this parallel.</description></item>
            <item><term>latitude_of_2nd_standard_parallel</term><description>For a conic projection with two standard parallels, this is the latitude of intersection of the cone with the ellipsoid that is furthest from the pole.  Scale is true along this parallel.</description></item>
            <item><term>easting_at_false_origin</term><description>The easting value assigned to the false origin.</description></item>
            <item><term>northing_at_false_origin</term><description>The northing value assigned to the false origin.</description></item>
            </list>
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.AlbersProjection.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter},System.Boolean)">
            <summary>
            Creates an instance of an Albers projection object.
            </summary>
            <remarks>
            <para>The parameters this projection expects are listed below.</para>
            <list type="table">
            <listheader><term>Items</term><description>Descriptions</description></listheader>
            <item><term>latitude_of_center</term><description>The latitude of the point which is not the natural origin and at which grid coordinate values false easting and false northing are defined.</description></item>
            <item><term>longitude_of_center</term><description>The longitude of the point which is not the natural origin and at which grid coordinate values false easting and false northing are defined.</description></item>
            <item><term>standard_parallel_1</term><description>For a conic projection with two standard parallels, this is the latitude of intersection of the cone with the ellipsoid that is nearest the pole.  Scale is true along this parallel.</description></item>
            <item><term>standard_parallel_2</term><description>For a conic projection with two standard parallels, this is the latitude of intersection of the cone with the ellipsoid that is furthest from the pole.  Scale is true along this parallel.</description></item>
            <item><term>false_easting</term><description>The easting value assigned to the false origin.</description></item>
            <item><term>false_northing</term><description>The northing value assigned to the false origin.</description></item>
            </list>
            </remarks>
            <param name="parameters">List of parameters to initialize the projection.</param>
            <param name="isInverse">Indicates whether the projection forward (meters to degrees or degrees to meters).</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.AlbersProjection.DegreesToMeters(System.Double[])">
            <summary>
            Converts coordinates in decimal degrees to projected meters.
            </summary>
            <param name="lonlat">The point in decimal degrees.</param>
            <returns>Point in projected meters</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.AlbersProjection.MetersToDegrees(System.Double[])">
            <summary>
            Converts coordinates in projected meters to decimal degrees.
            </summary>
            <param name="p">Point in meters</param>
            <returns>Transformed point in decimal degrees</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.AlbersProjection.Inverse">
            <summary>
            Returns the inverse of this projection.
            </summary>
            <returns>IMathTransform that is the reverse of the current projection.</returns>
        </member>
        <member name="T:SharpMap.CoordinateSystems.PrimeMeridian">
            <summary>
            A meridian used to take longitude measurements from.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.PrimeMeridian.#ctor(System.Double,SharpMap.CoordinateSystems.IAngularUnit,System.String,System.String,System.Int64,System.String,System.String,System.String)">
            <summary>
            Initializes a new instance of a prime meridian
            </summary>
            <param name="longitude">Longitude of prime meridian</param>
            <param name="angularUnit">Angular unit</param>
            <param name="name">Name</param>
            <param name="authority">Authority name</param>
            <param name="authorityCode">Authority-specific identification code.</param>
            <param name="alias">Alias</param>
            <param name="abbreviation">Abbreviation</param>
            <param name="remarks">Provider-supplied remarks</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.PrimeMeridian.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Greenwich">
            <summary>
            Greenwich prime meridian
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Lisbon">
            <summary>
            Lisbon prime meridian
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Paris">
            <summary>
            Paris prime meridian.
            Value adopted by IGN (Paris) in 1936. Equivalent to 2 deg 20min 14.025sec. Preferred by EPSG to earlier value of 2deg 20min 13.95sec (2.596898 grads) used by RGS London.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Bogota">
            <summary>
            Bogota prime meridian
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Madrid">
            <summary>
            Madrid prime meridian
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Rome">
            <summary>
            Rome prime meridian
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Bern">
            <summary>
            Bern prime meridian.
            1895 value. Newer value of 7 deg 26 min 22.335 sec E determined in 1938.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Jakarta">
            <summary>
            Jakarta prime meridian
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Ferro">
            <summary>
            Ferro prime meridian.
            Used in Austria and former Czechoslovakia.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Brussels">
            <summary>
            Brussels prime meridian
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Stockholm">
            <summary>
            Stockholm prime meridian
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Athens">
            <summary>
            Athens prime meridian.
            Used in Greece for older mapping based on Hatt projection.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Oslo">
            <summary>
            Oslo prime meridian.
            Formerly known as Kristiania or Christiania.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.Longitude">
            <summary>
            Gets or sets the longitude of the prime meridian (relative to the Greenwich prime meridian).
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.AngularUnit">
            <summary>
            Gets or sets the AngularUnits.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.PrimeMeridian.XML">
            <summary>
            Gets an XML representation of this object
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IGeographicCoordinateSystem">
            <summary>
            The IGeographicCoordinateSystem interface is a subclass of IGeodeticSpatialReference and
            defines the standard information stored with geographic coordinate system objects.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.IGeographicCoordinateSystem.GetWgs84ConversionInfo(System.Int32)">
            <summary>
            Gets details on a conversion to WGS84.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IGeographicCoordinateSystem.AngularUnit">
            <summary>
            Gets or sets the angular units of the geographic coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IGeographicCoordinateSystem.PrimeMeridian">
            <summary>
            Gets or sets the prime meridian of the geographic coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IGeographicCoordinateSystem.NumConversionToWGS84">
            <summary>
            Gets the number of available conversions to WGS84 coordinates.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IGeocentricCoordinateSystem">
            <summary>
            A 3D coordinate system, with its origin at the center of the Earth.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IGeocentricCoordinateSystem.HorizontalDatum">
            <summary>
            Returns the HorizontalDatum. The horizontal datum is used to determine where
            the centre of the Earth is considered to be. All coordinate points will be 
            measured from the centre of the Earth, and not the surface.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IGeocentricCoordinateSystem.LinearUnit">
            <summary>
            Gets the units used along all the axes.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IGeocentricCoordinateSystem.PrimeMeridian">
            <summary>
            Returns the PrimeMeridian.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.AngularUnit">
            <summary>
            Definition of angular units.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.AngularUnit.#ctor(System.Double)">
            <summary>
            Initializes a new instance of a angular unit
            </summary>
            <param name="radiansPerUnit">Radians per unit</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.AngularUnit.#ctor(System.Double,System.String,System.String,System.Int64,System.String,System.String,System.String)">
            <summary>
            Initializes a new instance of a angular unit
            </summary>
            <param name="radiansPerUnit">Radians per unit</param>
            <param name="name">Name</param>
            <param name="authority">Authority name</param>
            <param name="authorityCode">Authority-specific identification code.</param>
            <param name="alias">Alias</param>
            <param name="abbreviation">Abbreviation</param>
            <param name="remarks">Provider-supplied remarks</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.AngularUnit.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.AngularUnit.Degrees">
            <summary>
            The angular degrees are PI/180 = 0.017453292519943295769236907684886 radians
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.AngularUnit.Radian">
            <summary>
            SI standard unit
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.AngularUnit.Grad">
            <summary>
            Pi / 200 = 0.015707963267948966192313216916398 radians
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.AngularUnit.Gon">
            <summary>
            Pi / 200 = 0.015707963267948966192313216916398 radians
            </summary>		
        </member>
        <member name="P:SharpMap.CoordinateSystems.AngularUnit.RadiansPerUnit">
            <summary>
            Gets or sets the number of radians per <see cref="T:SharpMap.CoordinateSystems.AngularUnit"/>.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.AngularUnit.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.AngularUnit.XML">
            <summary>
            Gets an XML representation of this object.
            </summary>
        </member>
        <member name="T:SharpMap.Converters.WellKnownText.TokenType">
            <summary>
            Represents the type of token created by the StreamTokenizer class.
            </summary>
        </member>
        <member name="F:SharpMap.Converters.WellKnownText.TokenType.Word">
            <summary>
            Indicates that the token is a word.
            </summary>
        </member>
        <member name="F:SharpMap.Converters.WellKnownText.TokenType.Number">
            <summary>
            Indicates that the token is a number. 
            </summary>
        </member>
        <member name="F:SharpMap.Converters.WellKnownText.TokenType.Eol">
            <summary>
            Indicates that the end of line has been read. The field can only have this value if the eolIsSignificant method has been called with the argument true. 
            </summary>
        </member>
        <member name="F:SharpMap.Converters.WellKnownText.TokenType.Eof">
            <summary>
            Indicates that the end of the input stream has been reached.
            </summary>
        </member>
        <member name="F:SharpMap.Converters.WellKnownText.TokenType.Whitespace">
            <summary>
            Indictaes that the token is white space (space, tab, newline).
            </summary>
        </member>
        <member name="F:SharpMap.Converters.WellKnownText.TokenType.Symbol">
            <summary>
            Characters that are not whitespace, numbers, etc...
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.ConcatenatedTransform">
            <summary>
            
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.ConcatenatedTransform._inverse">
            <summary>
            
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.ConcatenatedTransform.#ctor">
            <summary>
            
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.ConcatenatedTransform.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.Transformations.ICoordinateTransformation})">
            <summary>
            
            </summary>
            <param name="transformlist"></param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.ConcatenatedTransform.Transform(System.Double[])">
            <summary>
            Transforms a point
            </summary>
            <param name="point"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.ConcatenatedTransform.TransformList(System.Collections.Generic.List{System.Double[]})">
            <summary>
            Transforms a list point
            </summary>
            <param name="points"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.ConcatenatedTransform.Inverse">
            <summary>
            Returns the inverse of this conversion.
            </summary>
            <returns>IMathTransform that is the reverse of the current conversion.</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.ConcatenatedTransform.Invert">
            <summary>
            Reverses the transformation
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.ConcatenatedTransform.CoordinateTransformationList">
            <summary>
            
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.ConcatenatedTransform.WKT">
            <summary>
            Gets a Well-Known text representation of this object.
            </summary>
            <value></value>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Transformations.ConcatenatedTransform.XML">
            <summary>
            Gets an XML representation of this object.
            </summary>
            <value></value>
        </member>
        <member name="T:SharpMap.CoordinateSystems.ICoordinateSystemFactory">
            <summary>
            Builds up complex objects from simpler objects or values.
            </summary>
            <remarks>
            <para>ICoordinateSystemFactory allows applications to make coordinate systems that 
            cannot be created by a <see cref="T:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory"/>. This factory is very 
            flexible, whereas the authority factory is easier to use.</para>
            <para>So <see cref="T:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory"/>can be used to make 'standard' coordinate 
            systems, and <see cref="T:SharpMap.CoordinateSystems.CoordinateSystemFactory"/> can be used to make 'special' 
            coordinate systems.</para>
            <para>For example, the EPSG authority has codes for USA state plane coordinate systems 
            using the NAD83 datum, but these coordinate systems always use meters. EPSG does not 
            have codes for NAD83 state plane coordinate systems that use feet units. This factory
            lets an application create such a hybrid coordinate system.</para>
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateCompoundCoordinateSystem(System.String,SharpMap.CoordinateSystems.ICoordinateSystem,SharpMap.CoordinateSystems.ICoordinateSystem)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.ICompoundCoordinateSystem"/>.
            </summary>
            <param name="name">Name of compound coordinate system.</param>
            <param name="head">Head coordinate system</param>
            <param name="tail">Tail coordinate system</param>
            <returns>Compound coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateEllipsoid(System.String,System.Double,System.Double,SharpMap.CoordinateSystems.ILinearUnit)">
            <summary>
            Creates an <see cref="T:SharpMap.CoordinateSystems.IEllipsoid"/> from radius values.
            </summary>
            <seealso cref="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateFlattenedSphere(System.String,System.Double,System.Double,SharpMap.CoordinateSystems.ILinearUnit)"/>
            <param name="name">Name of ellipsoid</param>
            <param name="semiMajorAxis"></param>
            <param name="semiMinorAxis"></param>
            <param name="linearUnit"></param>
            <returns>Ellipsoid</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateFittedCoordinateSystem(System.String,SharpMap.CoordinateSystems.ICoordinateSystem,System.String,System.Collections.Generic.List{SharpMap.CoordinateSystems.AxisInfo})">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.IFittedCoordinateSystem"/>.
            </summary>
            <remarks>The units of the axes in the fitted coordinate system will be 
            inferred from the units of the base coordinate system. If the affine map
            performs a rotation, then any mixed axes must have identical units. For
            example, a (lat_deg,lon_deg,height_feet) system can be rotated in the 
            (lat,lon) plane, since both affected axes are in degrees. But you 
            should not rotate this coordinate system in any other plane.</remarks>
            <param name="name">Name of coordinate system</param>
            <param name="baseCoordinateSystem">Base coordinate system</param>
            <param name="toBaseWkt"></param>
            <param name="arAxes"></param>
            <returns>Fitted coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateFlattenedSphere(System.String,System.Double,System.Double,SharpMap.CoordinateSystems.ILinearUnit)">
            <summary>
            Creates an <see cref="T:SharpMap.CoordinateSystems.IEllipsoid"/> from an major radius, and inverse flattening.
            </summary>
            <seealso cref="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateEllipsoid(System.String,System.Double,System.Double,SharpMap.CoordinateSystems.ILinearUnit)"/>
            <param name="name">Name of ellipsoid</param>
            <param name="semiMajorAxis">Semi major-axis</param>
            <param name="inverseFlattening">Inverse flattening</param>
            <param name="linearUnit">Linear unit</param>
            <returns>Ellipsoid</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateFromXml(System.String)">
            <summary>
            Creates a coordinate system object from an XML string.
            </summary>
            <param name="xml">XML representation for the spatial reference</param>
            <returns>The resulting spatial reference object</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateFromWkt(System.String)">
            <summary>
            Creates a spatial reference object given its Well-known text representation.
            The output object may be either a <see cref="T:SharpMap.CoordinateSystems.IGeographicCoordinateSystem"/> or
            a <see cref="T:SharpMap.CoordinateSystems.IProjectedCoordinateSystem"/>.
            </summary>
            <param name="WKT">The Well-known text representation for the spatial reference</param>
            <returns>The resulting spatial reference object</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateGeographicCoordinateSystem(System.String,SharpMap.CoordinateSystems.IAngularUnit,SharpMap.CoordinateSystems.IHorizontalDatum,SharpMap.CoordinateSystems.IPrimeMeridian,SharpMap.CoordinateSystems.AxisInfo,SharpMap.CoordinateSystems.AxisInfo)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.IGeographicCoordinateSystem"/>, which could be Lat/Lon or Lon/Lat.
            </summary>
            <param name="name">Name of geographical coordinate system</param>
            <param name="angularUnit">Angular units</param>
            <param name="datum">Horizontal datum</param>
            <param name="primeMeridian">Prime meridian</param>
            <param name="axis0">First axis</param>
            <param name="axis1">Second axis</param>
            <returns>Geographic coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateHorizontalDatum(System.String,SharpMap.CoordinateSystems.DatumType,SharpMap.CoordinateSystems.IEllipsoid,SharpMap.CoordinateSystems.Wgs84ConversionInfo)">
            <summary>
            Creates <see cref="T:SharpMap.CoordinateSystems.IHorizontalDatum"/> from ellipsoid and Bursa-World parameters.
            </summary>
            <remarks>
            Since this method contains a set of Bursa-Wolf parameters, the created 
            datum will always have a relationship to WGS84. If you wish to create a
            horizontal datum that has no relationship with WGS84, then you can 
            either specify a <see cref="T:SharpMap.CoordinateSystems.DatumType">horizontalDatumType</see> of <see cref="F:SharpMap.CoordinateSystems.DatumType.HD_Other"/>, or create it via WKT.
            </remarks>
            <param name="name">Name of ellipsoid</param>
            <param name="datumType">Type of datum</param>
            <param name="ellipsoid">Ellipsoid</param>
            <param name="toWgs84">Wgs84 conversion parameters</param>
            <returns>Horizontal datum</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateLocalCoordinateSystem(System.String,SharpMap.CoordinateSystems.ILocalDatum,SharpMap.CoordinateSystems.IUnit,System.Collections.Generic.List{SharpMap.CoordinateSystems.AxisInfo})">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.ILocalCoordinateSystem">local coordinate system</see>.
            </summary>
            <remarks>
             The dimension of the local coordinate system is determined by the size of 
            the axis array. All the axes will have the same units. If you want to make 
            a coordinate system with mixed units, then you can make a compound 
            coordinate system from different local coordinate systems.
            </remarks>
            <param name="name">Name of local coordinate system</param>
            <param name="datum">Local datum</param>
            <param name="unit">Units</param>
            <param name="axes">Axis info</param>
            <returns>Local coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateLocalDatum(System.String,SharpMap.CoordinateSystems.DatumType)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.ILocalDatum"/>.
            </summary>
            <param name="name">Name of datum</param>
            <param name="datumType">Datum type</param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreatePrimeMeridian(System.String,SharpMap.CoordinateSystems.IAngularUnit,System.Double)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.IPrimeMeridian"/>, relative to Greenwich.
            </summary>
            <param name="name">Name of prime meridian</param>
            <param name="angularUnit">Angular unit</param>
            <param name="longitude">Longitude</param>
            <returns>Prime meridian</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateProjectedCoordinateSystem(System.String,SharpMap.CoordinateSystems.IGeographicCoordinateSystem,SharpMap.CoordinateSystems.IProjection,SharpMap.CoordinateSystems.ILinearUnit,SharpMap.CoordinateSystems.AxisInfo,SharpMap.CoordinateSystems.AxisInfo)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.IProjectedCoordinateSystem"/> using a projection object.
            </summary>
            <param name="name">Name of projected coordinate system</param>
            <param name="gcs">Geographic coordinate system</param>
            <param name="projection">Projection</param>
            <param name="linearUnit">Linear unit</param>
            <param name="axis0">Primary axis</param>
            <param name="axis1">Secondary axis</param>
            <returns>Projected coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateProjection(System.String,System.String,System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter})">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.IProjection"/>.
            </summary>
            <param name="name">Name of projection</param>
            <param name="wktProjectionClass">Projection class</param>
            <param name="Parameters">Projection parameters</param>
            <returns>Projection</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateVerticalCoordinateSystem(System.String,SharpMap.CoordinateSystems.IVerticalDatum,SharpMap.CoordinateSystems.ILinearUnit,SharpMap.CoordinateSystems.AxisInfo)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.IVerticalCoordinateSystem"/> from a <see cref="T:SharpMap.CoordinateSystems.IVerticalDatum">datum</see> and <see cref="T:SharpMap.CoordinateSystems.ILinearUnit">linear units</see>.
            </summary>
            <param name="name">Name of vertical coordinate system</param>
            <param name="datum">Vertical datum</param>
            <param name="verticalUnit">Unit</param>
            <param name="axis">Axis info</param>
            <returns>Vertical coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemFactory.CreateVerticalDatum(System.String,SharpMap.CoordinateSystems.DatumType)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.IVerticalDatum"/> from an enumerated type value.
            </summary>
            <param name="name">Name of datum</param>
            <param name="datumType">Type of datum</param>
            <returns>Vertical datum</returns>	
        </member>
        <member name="T:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory">
            <summary>
            Creates spatial reference objects using codes.
            </summary>
            <remarks>
             The codes are maintained by an external authority. A commonly used authority is EPSG, which is also used in the GeoTIFF standard and in SharpMap.
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.CreateProjectedCoordinateSystem(System.Int64)">
            <summary>
            Returns a projected coordinate system object corresponding to the given code.
            </summary>
            <param name="code">The identification code.</param>
            <returns>The projected coordinate system object with the given code.</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.CreateGeographicCoordinateSystem(System.Int64)">
            <summary>
            Returns a geographic coordinate system object corresponding to the given code.
            </summary>
            <param name="code">The identification code.</param>
            <returns>The geographic coordinate system object with the given code.</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.CreateHorizontalDatum(System.Int64)">
            <summary>
            Returns a horizontal datum object corresponding to the given code.
            </summary>
            <param name="code">The identification code.</param>
            <returns>The horizontal datum object with the given code.</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.CreateEllipsoid(System.Int64)">
            <summary>
            Returns an ellipsoid object corresponding to the given code.
            </summary>
            <param name="code">The identification code.</param>
            <returns>The ellipsoid object with the given code.</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.CreatePrimeMeridian(System.Int64)">
            <summary>
            Returns a prime meridian object corresponding to the given code.
            </summary>
            <param name="code">The identification code.</param>
            <returns>The prime meridian object with the given code.</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.CreateLinearUnit(System.Int64)">
            <summary>
            Returns a linear unit object corresponding to the given code.
            </summary>
            <param name="code">The identification code.</param>
            <returns>The linear unit object with the given code.</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.CreateAngularUnit(System.Int64)">
            <summary>
            Returns an <see cref="T:SharpMap.CoordinateSystems.IAngularUnit">angular unit</see> object corresponding to the given code.
            </summary>
            <param name="code">The identification code.</param>
            <returns>The angular unit object for the given code.</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.CreateVerticalDatum(System.Int64)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.IVerticalDatum"/> from a code.
            </summary>
            <param name="code">Authority code</param>
            <returns>Vertical datum for the given code</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.CreateVerticalCoordinateSystem(System.Int64)">
            <summary>
            Create a <see cref="T:SharpMap.CoordinateSystems.IVerticalCoordinateSystem">vertical coordinate system</see> from a code.
            </summary>
            <param name="code">Authority code</param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.CreateCompoundCoordinateSystem(System.Int64)">
            <summary>
            Creates a 3D coordinate system from a code.
            </summary>
            <param name="code">Authority code</param>
            <returns>Compound coordinate system for the given code</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.CreateHorizontalCoordinateSystem(System.Int64)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.IHorizontalCoordinateSystem">horizontal co-ordinate system</see> from a code.
            The horizontal coordinate system could be geographic or projected.
            </summary>
            <param name="code">Authority code</param>
            <returns>Horizontal coordinate system for the given code</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.GeoidFromWktName(System.String)">
            <summary>
            Gets the Geoid code from a WKT name.
            </summary>
            <remarks>
             In the OGC definition of WKT horizontal datums, the geoid is referenced 
            by a quoted string, which is used as a key value. This method converts 
            the key value string into a code recognized by this authority.
            </remarks>
            <param name="wkt"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.WktGeoidName(System.String)">
            <summary>
            Gets the WKT name of a Geoid.
            </summary>
            <remarks>
             In the OGC definition of WKT horizontal datums, the geoid is referenced by 
            a quoted string, which is used as a key value. This method gets the OGC WKT 
            key value from a geoid code.
            </remarks>
            <param name="geoid"></param>
            <returns></returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.Authority">
            <summary>
            Returns the authority name for this factory (e.g., "EPSG" or "POSC").
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory.DescriptionText">
            <summary>
            Gets a description of the object corresponding to a code.
            </summary>
        </member>
        <member name="T:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader">
            <summary>
            Creates an object based on the supplied Well Known Text (WKT).
            </summary>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.Parse(System.String)">
            <summary>
            Reads and parses a WKT-formatted projection string.
            </summary>
            <param name="wkt">String containing WKT.</param>
            <returns>Object representation of the WKT.</returns>
            <exception cref="T:System.ArgumentException">If a token is not recognised.</exception>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.ReadUnit(SharpMap.Converters.WellKnownText.WktStreamTokenizer)">
            <summary>
            Returns a IUnit given a piece of WKT.
            </summary>
            <param name="tokenizer">WktStreamTokenizer that has the WKT.</param>
            <returns>An object that implements the IUnit interface.</returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.ReadLinearUnit(SharpMap.Converters.WellKnownText.WktStreamTokenizer)">
            <summary>
            Returns a <see cref="T:SharpMap.CoordinateSystems.LinearUnit"/> given a piece of WKT.
            </summary>
            <param name="tokenizer">WktStreamTokenizer that has the WKT.</param>
            <returns>An object that implements the IUnit interface.</returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.ReadAngularUnit(SharpMap.Converters.WellKnownText.WktStreamTokenizer)">
            <summary>
            Returns a <see cref="T:SharpMap.CoordinateSystems.AngularUnit"/> given a piece of WKT.
            </summary>
            <param name="tokenizer">WktStreamTokenizer that has the WKT.</param>
            <returns>An object that implements the IUnit interface.</returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.ReadAxis(SharpMap.Converters.WellKnownText.WktStreamTokenizer)">
            <summary>
            Returns a <see cref="T:SharpMap.CoordinateSystems.AxisInfo"/> given a piece of WKT.
            </summary>
            <param name="tokenizer">WktStreamTokenizer that has the WKT.</param>
            <returns>An AxisInfo object.</returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.ReadCoordinateSystem(System.String,SharpMap.Converters.WellKnownText.WktStreamTokenizer)">
            <summary>
            
            </summary>
            <param name="coordinateSystem"></param>
            <param name="tokenizer"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.ReadWGS84ConversionInfo(SharpMap.Converters.WellKnownText.WktStreamTokenizer)">
            <summary>
            Reads either 3, 6 or 7 parameter Bursa-Wolf values from TOWGS84 token
            </summary>
            <param name="tokenizer"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.ReadEllipsoid(SharpMap.Converters.WellKnownText.WktStreamTokenizer)">
            <summary>
            
            </summary>
            <param name="tokenizer"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.ReadProjection(SharpMap.Converters.WellKnownText.WktStreamTokenizer)">
            <summary>
            
            </summary>
            <param name="tokenizer"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.ReadProjectedCoordinateSystem(SharpMap.Converters.WellKnownText.WktStreamTokenizer)">
            <summary>
            
            </summary>
            <param name="tokenizer"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.ReadGeographicCoordinateSystem(SharpMap.Converters.WellKnownText.WktStreamTokenizer)">
            <summary>
            
            </summary>
            <param name="tokenizer"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.ReadHorizontalDatum(SharpMap.Converters.WellKnownText.WktStreamTokenizer)">
            <summary>
            
            </summary>
            <param name="tokenizer"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.CoordinateSystemWktReader.ReadPrimeMeridian(SharpMap.Converters.WellKnownText.WktStreamTokenizer)">
            <summary>
            
            </summary>
            <param name="tokenizer"></param>
            <returns></returns>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Unit">
            <summary>
            Class for defining units
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Unit.#ctor(System.Double,System.String,System.String,System.Int64,System.String,System.String,System.String)">
            <summary>
            Initializes a new unit
            </summary>
            <param name="conversionFactor">Conversion factor to base unit</param>
            <param name="name">Name of unit</param>
            <param name="authority">Authority name</param>
            <param name="authorityCode">Authority-specific identification code.</param>
            <param name="alias">Alias</param>
            <param name="abbreviation">Abbreviation</param>
            <param name="remarks">Provider-supplied remarks</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Unit.#ctor(System.String,System.Double)">
            <summary>
            Initializes a new unit
            </summary>
            <param name="name">Name of unit</param>
            <param name="conversionFactor">Conversion factor to base unit</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Unit.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Unit.ConversionFactor">
            <summary>
            Gets or sets the number of units per base-unit.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Unit.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Unit.XML">
            <summary>
            Gets an XML representation of this object [NOT IMPLEMENTED].
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IFittedCoordinateSystem">
            <summary>
            A coordinate system which sits inside another coordinate system. The fitted 
            coordinate system can be rotated and shifted, or use any other math transform
            to inject itself into the base coordinate system.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.IFittedCoordinateSystem.ToBase">
            <summary>
            Gets Well-Known Text of a math transform to the base coordinate system. 
            The dimension of this fitted coordinate system is determined by the source 
            dimension of the math transform. The transform should be one-to-one within 
            this coordinate system's domain, and the base coordinate system dimension 
            must be at least as big as the dimension of this coordinate system.
            </summary>
            <returns></returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IFittedCoordinateSystem.BaseCoordinateSystem">
            <summary>
            Gets underlying coordinate system.
            </summary>
        </member>
        <member name="T:SharpMap.Converters.WellKnownText.WktStreamTokenizer">
            <summary>
            Reads a stream of Well Known Text (wkt) string and returns a stream of tokens.
            </summary>
        </member>
        <member name="T:SharpMap.Converters.WellKnownText.IO.StreamTokenizer">
            <summary>
            The StreamTokenizer class takes an input stream and parses it into "tokens", allowing the tokens to be read one at a time. The parsing process is controlled by a table and a number of flags that can be set to various states. The stream tokenizer can recognize identifiers, numbers, quoted strings, and various comment style
            </summary>
            <remarks>
            This is a crude c# implementation of Java's <a href="http://java.sun.com/products/jdk/1.2/docs/api/java/io/StreamTokenizer.html">StreamTokenizer</a> class.
            </remarks>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.IO.StreamTokenizer.#ctor(System.IO.TextReader,System.Boolean)">
            <summary>
            Initializes a new instance of the StreamTokenizer class.
            </summary>
            <param name="reader">A TextReader with some text to read.</param>
            <param name="ignoreWhitespace">Flag indicating whether whitespace should be ignored.</param>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.IO.StreamTokenizer.GetNumericValue">
            <summary>
            If the current token is a number, this field contains the value of that number. 
            </summary>
            <remarks>
            If the current token is a number, this field contains the value of that number. The current token is a number when the value of the ttype field is TT_NUMBER.
            </remarks>
            <exception cref="T:System.FormatException">Current token is not a number in a valid format.</exception>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.IO.StreamTokenizer.GetStringValue">
            <summary>
            If the current token is a word token, this field contains a string giving the characters of the word token. 
            </summary>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.IO.StreamTokenizer.GetTokenType">
            <summary>
            Gets the token type of the current token.
            </summary>
            <returns></returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.IO.StreamTokenizer.NextToken(System.Boolean)">
            <summary>
            Returns the next token.
            </summary>
            <param name="ignoreWhitespace">Determines is whitespace is ignored. True if whitespace is to be ignored.</param>
            <returns>The TokenType of the next token.</returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.IO.StreamTokenizer.NextToken">
            <summary>
            Returns the next token.
            </summary>
            <returns>The TokenType of the next token.</returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.IO.StreamTokenizer.GetType(System.Char)">
            <summary>
            Determines a characters type (e.g. number, symbols, character).
            </summary>
            <param name="character">The character to determine.</param>
            <returns>The TokenType the character is.</returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.IO.StreamTokenizer.NextNonWhitespaceToken">
            <summary>
            Returns next token that is not whitespace.
            </summary>
            <returns></returns>
        </member>
        <member name="P:SharpMap.Converters.WellKnownText.IO.StreamTokenizer.LineNumber">
            <summary>
            The current line number of the stream being read.
            </summary>
        </member>
        <member name="P:SharpMap.Converters.WellKnownText.IO.StreamTokenizer.Column">
            <summary>
            The current column number of the stream being read.
            </summary>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.WktStreamTokenizer.#ctor(System.IO.TextReader)">
            <summary>
            Initializes a new instance of the WktStreamTokenizer class.
            </summary>
            <remarks>The WktStreamTokenizer class ais in reading WKT streams.</remarks>
            <param name="reader">A TextReader that contains </param>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.WktStreamTokenizer.ReadToken(System.String)">
            <summary>
            Reads a token and checks it is what is expected.
            </summary>
            <param name="expectedToken">The expected token.</param>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.WktStreamTokenizer.ReadDoubleQuotedWord">
            <summary>
            Reads a string inside double quotes.
            </summary>
            <remarks>
            White space inside quotes is preserved.
            </remarks>
            <returns>The string inside the double quotes.</returns>
        </member>
        <member name="M:SharpMap.Converters.WellKnownText.WktStreamTokenizer.ReadAuthority(System.String@,System.Int64@)">
            <summary>
            Reads the authority and authority code.
            </summary>
            <param name="authority">String to place the authority in.</param>
            <param name="authorityCode">String to place the authority code in.</param>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Projections.TransverseMercator">
            <summary>
            Summary description for MathTransform.
            </summary>
            <remarks>
            <para>Universal (UTM) and Modified (MTM) Transverses Mercator projections. This
            is a cylindrical projection, in which the cylinder has been rotated 90°.
            Instead of being tangent to the equator (or to an other standard latitude),
            it is tangent to a central meridian. Deformation are more important as we
            are going futher from the central meridian. The Transverse Mercator
            projection is appropriate for region wich have a greater extent north-south
            than east-west.</para>
            
            <para>Reference: John P. Snyder (Map Projections - A Working Manual,
                       U.S. Geological Survey Professional Paper 1395, 1987)</para>
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.TransverseMercator.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter})">
            <summary>
            Creates an instance of an TransverseMercatorProjection projection object.
            </summary>
            <param name="parameters">List of parameters to initialize the projection.</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.TransverseMercator.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter},System.Boolean)">
            <summary>
            Creates an instance of an TransverseMercatorProjection projection object.
            </summary>
            <param name="parameters">List of parameters to initialize the projection.</param>
            <param name="inverse">Flag indicating wether is a forward/projection (false) or an inverse projection (true).</param>
            <remarks>
            <list type="bullet">
            <listheader><term>Items</term><description>Descriptions</description></listheader>
            <item><term>semi_major</term><description>Semi major radius</description></item>
            <item><term>semi_minor</term><description>Semi minor radius</description></item>
            <item><term>scale_factor</term><description></description></item>
            <item><term>central meridian</term><description></description></item>
            <item><term>latitude_origin</term><description></description></item>
            <item><term>false_easting</term><description></description></item>
            <item><term>false_northing</term><description></description></item>
            </list>
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.TransverseMercator.DegreesToMeters(System.Double[])">
            <summary>
            Converts coordinates in decimal degrees to projected meters.
            </summary>
            <param name="lonlat">The point in decimal degrees.</param>
            <returns>Point in projected meters</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.TransverseMercator.MetersToDegrees(System.Double[])">
            <summary>
            Converts coordinates in projected meters to decimal degrees.
            </summary>
            <param name="p">Point in meters</param>
            <returns>Transformed point in decimal degrees</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.TransverseMercator.Inverse">
            <summary>
            Returns the inverse of this projection.
            </summary>
            <returns>IMathTransform that is the reverse of the current projection.</returns>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Projections.LambertConformalConic2SP">
            <summary>
            Implemetns the Lambert Conformal Conic 2SP Projection.
            </summary>
            <remarks>
            <para>The Lambert Conformal Conic projection is a standard projection for presenting maps
            of land areas whose East-West extent is large compared with their North-South extent.
            This projection is "conformal" in the sense that lines of latitude and longitude, 
            which are perpendicular to one another on the earth's surface, are also perpendicular
            to one another in the projected domain.</para>
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.LambertConformalConic2SP.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter})">
            <summary>
            Creates an instance of an LambertConformalConic2SPProjection projection object.
            </summary>
            <remarks>
            <para>The parameters this projection expects are listed below.</para>
            <list type="table">
            <listheader><term>Items</term><description>Descriptions</description></listheader>
            <item><term>latitude_of_false_origin</term><description>The latitude of the point which is not the natural origin and at which grid coordinate values false easting and false northing are defined.</description></item>
            <item><term>longitude_of_false_origin</term><description>The longitude of the point which is not the natural origin and at which grid coordinate values false easting and false northing are defined.</description></item>
            <item><term>latitude_of_1st_standard_parallel</term><description>For a conic projection with two standard parallels, this is the latitude of intersection of the cone with the ellipsoid that is nearest the pole.  Scale is true along this parallel.</description></item>
            <item><term>latitude_of_2nd_standard_parallel</term><description>For a conic projection with two standard parallels, this is the latitude of intersection of the cone with the ellipsoid that is furthest from the pole.  Scale is true along this parallel.</description></item>
            <item><term>easting_at_false_origin</term><description>The easting value assigned to the false origin.</description></item>
            <item><term>northing_at_false_origin</term><description>The northing value assigned to the false origin.</description></item>
            </list>
            </remarks>
            <param name="parameters">List of parameters to initialize the projection.</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.LambertConformalConic2SP.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter},System.Boolean)">
            <summary>
            Creates an instance of an Albers projection object.
            </summary>
            <remarks>
            <para>The parameters this projection expects are listed below.</para>
            <list type="table">
            <listheader><term>Parameter</term><description>Description</description></listheader>
            <item><term>latitude_of_origin</term><description>The latitude of the point which is not the natural origin and at which grid coordinate values false easting and false northing are defined.</description></item>
            <item><term>central_meridian</term><description>The longitude of the point which is not the natural origin and at which grid coordinate values false easting and false northing are defined.</description></item>
            <item><term>standard_parallel_1</term><description>For a conic projection with two standard parallels, this is the latitude of intersection of the cone with the ellipsoid that is nearest the pole.  Scale is true along this parallel.</description></item>
            <item><term>standard_parallel_2</term><description>For a conic projection with two standard parallels, this is the latitude of intersection of the cone with the ellipsoid that is furthest from the pole.  Scale is true along this parallel.</description></item>
            <item><term>false_easting</term><description>The easting value assigned to the false origin.</description></item>
            <item><term>false_northing</term><description>The northing value assigned to the false origin.</description></item>
            </list>
            </remarks>
            <param name="parameters">List of parameters to initialize the projection.</param>
            <param name="isInverse">Indicates whether the projection forward (meters to degrees or degrees to meters).</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.LambertConformalConic2SP.DegreesToMeters(System.Double[])">
            <summary>
            Converts coordinates in decimal degrees to projected meters.
            </summary>
            <param name="lonlat">The point in decimal degrees.</param>
            <returns>Point in projected meters</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.LambertConformalConic2SP.MetersToDegrees(System.Double[])">
            <summary>
            Converts coordinates in projected meters to decimal degrees.
            </summary>
            <param name="p">Point in meters</param>
            <returns>Transformed point in decimal degrees</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.LambertConformalConic2SP.Inverse">
            <summary>
            Returns the inverse of this projection.
            </summary>
            <returns>IMathTransform that is the reverse of the current projection.</returns>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IParameterInfo">
            <summary>
            The IParameterInfo interface provides an interface through which clients of a
            Projected Coordinate System or of a Projection can set the parameters of the
            projection. It provides a generic interface for discovering the names and default
            values of parameters, and for setting and getting parameter values. Subclasses of
            this interface may provide projection specific parameter access methods.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.IParameterInfo.DefaultParameters">
            <summary>
            Returns the default parameters for this projection.
            </summary>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.IParameterInfo.GetParameterByName(System.String)">
            <summary>
            Gets the parameter by its name
            </summary>
            <param name="name"></param>
            <returns></returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IParameterInfo.NumParameters">
            <summary>
            Gets the number of parameters expected.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IParameterInfo.Parameters">
            <summary>
            Gets or sets the parameters set for this projection.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.HorizontalDatum">
            <summary>
            Horizontal datum defining the standard datum information.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Datum">
            <summary>
            A set of quantities from which other quantities are calculated.
            </summary>
            <remarks>
            For the OGC abstract model, it can be defined as a set of real points on the earth 
            that have coordinates. EG. A datum can be thought of as a set of parameters 
            defining completely the origin and orientation of a coordinate system with respect 
            to the earth. A textual description and/or a set of parameters describing the 
            relationship of a coordinate system to some predefined physical locations (such 
            as center of mass) and physical directions (such as axis of spin). The definition 
            of the datum may also include the temporal behavior (such as the rate of change of
            the orientation of the coordinate axes).
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Datum.#ctor(SharpMap.CoordinateSystems.DatumType,System.String,System.String,System.Int64,System.String,System.String,System.String)">
            <summary>
            Initializes a new instance of a Datum object
            </summary>
            <param name="type">Datum type</param>
            <param name="name">Name</param>
            <param name="authority">Authority name</param>
            <param name="code">Authority-specific identification code.</param>
            <param name="alias">Alias</param>
            <param name="abbreviation">Abbreviation</param>
            <param name="remarks">Provider-supplied remarks</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Datum.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.Datum.DatumType">
            <summary>
            Gets or sets the type of the datum as an enumerated code.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IHorizontalDatum">
            <summary>
            Procedure used to measure positions on the surface of the Earth.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IHorizontalDatum.Ellipsoid">
            <summary>
            Gets or sets the ellipsoid of the datum.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IHorizontalDatum.Wgs84Parameters">
            <summary>
            Gets preferred parameters for a Bursa Wolf transformation into WGS84. The 7 returned values 
            correspond to (dx,dy,dz) in meters, (ex,ey,ez) in arc-seconds, and scaling in parts-per-million.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.HorizontalDatum.#ctor(SharpMap.CoordinateSystems.IEllipsoid,SharpMap.CoordinateSystems.Wgs84ConversionInfo,SharpMap.CoordinateSystems.DatumType,System.String,System.String,System.Int64,System.String,System.String,System.String)">
            <summary>
            Initializes a new instance of a horizontal datum
            </summary>
            <param name="ellipsoid">Ellipsoid</param>
            <param name="toWgs84">Parameters for a Bursa Wolf transformation into WGS84</param>
            <param name="type">Datum type</param>
            <param name="name">Name</param>
            <param name="authority">Authority name</param>
            <param name="code">Authority-specific identification code.</param>
            <param name="alias">Alias</param>
            <param name="abbreviation">Abbreviation</param>
            <param name="remarks">Provider-supplied remarks</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.HorizontalDatum.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.HorizontalDatum.WGS84">
            <summary>
            EPSG's WGS 84 datum has been the then current realisation. No distinction is made between the original WGS 84 
            frame, WGS 84 (G730), WGS 84 (G873) and WGS 84 (G1150). Since 1997, WGS 84 has been maintained within 10cm of 
            the then current ITRF.
            </summary>
            <remarks>
            <para>Area of use: World</para>
            <para>Origin description: Defined through a consistent set of station coordinates. These have changed with time: by 0.7m 
            on 29/6/1994 [WGS 84 (G730)], a further 0.2m on 29/1/1997 [WGS 84 (G873)] and a further 0.06m on 
            20/1/2002 [WGS 84 (G1150)].</para>
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.HorizontalDatum.WGS72">
            <summary>
            World Geodetic System 1972
            </summary>
            <remarks>
            <para>Used by GPS before 1987. For Transit satellite positioning see also WGS 72BE. Datum code 6323 reserved for southern hemisphere ProjCS's.</para>
            <para>Area of use: World</para>
            <para>Origin description: Developed from a worldwide distribution of terrestrial and
            geodetic satellite observations and defined through a set of station coordinates.</para>
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.HorizontalDatum.ETRF89">
            <summary>
            European Terrestrial Reference System 1989
            </summary>
            <remarks>
            <para>Area of use: 
            Europe: Albania; Andorra; Austria; Belgium; Bosnia and Herzegovina; Bulgaria; Croatia; 
            Cyprus; Czech Republic; Denmark; Estonia; Finland; Faroe Islands; France; Germany; Greece; 
            Hungary; Ireland; Italy; Latvia; Liechtenstein; Lithuania; Luxembourg; Malta; Netherlands; 
            Norway; Poland; Portugal; Romania; San Marino; Serbia and Montenegro; Slovakia; Slovenia; 
            Spain; Svalbard; Sweden; Switzerland; United Kingdom (UK) including Channel Islands and 
            Isle of Man; Vatican City State.</para>
            <para>Origin description: Fixed to the stable part of the Eurasian continental 
            plate and consistent with ITRS at the epoch 1989.0.</para>
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.HorizontalDatum.ED50">
            <summary>
            European Datum 1950
            </summary>
            <remarks>
            <para>Area of use:
            Europe - west - Denmark; Faroe Islands; France offshore; Israel offshore; Italy including San 
            Marino and Vatican City State; Ireland offshore; Netherlands offshore; Germany; Greece (offshore);
            North Sea; Norway; Spain; Svalbard; Turkey; United Kingdom UKCS offshore. Egypt - Western Desert.
            </para>
            <para>Origin description: Fundamental point: Potsdam (Helmert Tower). 
            Latitude: 52 deg 22 min 51.4456 sec N; Longitude: 13 deg  3 min 58.9283 sec E (of Greenwich).</para>
            </remarks>
        </member>
        <member name="P:SharpMap.CoordinateSystems.HorizontalDatum.Ellipsoid">
            <summary>
            Gets or sets the ellipsoid of the datum
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.HorizontalDatum.Wgs84Parameters">
            <summary>
            Gets preferred parameters for a Bursa Wolf transformation into WGS84
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.HorizontalDatum.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.HorizontalDatum.XML">
            <summary>
            Gets an XML representation of this object
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.CoordinateSystemFactory">
            <summary>
            Builds up complex objects from simpler objects or values.
            </summary>
            <remarks>
            <para>ICoordinateSystemFactory allows applications to make coordinate systems that 
            cannot be created by a <see cref="T:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory"/>. This factory is very 
            flexible, whereas the authority factory is easier to use.</para>
            <para>So <see cref="T:SharpMap.CoordinateSystems.ICoordinateSystemAuthorityFactory"/>can be used to make 'standard' coordinate 
            systems, and <see cref="T:SharpMap.CoordinateSystems.CoordinateSystemFactory"/> can be used to make 'special' 
            coordinate systems.</para>
            <para>For example, the EPSG authority has codes for USA state plane coordinate systems 
            using the NAD83 datum, but these coordinate systems always use meters. EPSG does not 
            have codes for NAD83 state plane coordinate systems that use feet units. This factory
            lets an application create such a hybrid coordinate system.</para>
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateFromXml(System.String)">
            <summary>
            Creates a coordinate system object from an XML string.
            </summary>
            <param name="xml">XML representation for the spatial reference</param>
            <returns>The resulting spatial reference object</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateFromWkt(System.String)">
            <summary>
            Creates a spatial reference object given its Well-known text representation.
            The output object may be either a <see cref="T:SharpMap.CoordinateSystems.IGeographicCoordinateSystem"/> or
            a <see cref="T:SharpMap.CoordinateSystems.IProjectedCoordinateSystem"/>.
            </summary>
            <param name="WKT">The Well-known text representation for the spatial reference</param>
            <returns>The resulting spatial reference object</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateCompoundCoordinateSystem(System.String,SharpMap.CoordinateSystems.ICoordinateSystem,SharpMap.CoordinateSystems.ICoordinateSystem)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.ICompoundCoordinateSystem"/> [NOT IMPLEMENTED].
            </summary>
            <param name="name">Name of compound coordinate system.</param>
            <param name="head">Head coordinate system</param>
            <param name="tail">Tail coordinate system</param>
            <returns>Compound coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateFittedCoordinateSystem(System.String,SharpMap.CoordinateSystems.ICoordinateSystem,System.String,System.Collections.Generic.List{SharpMap.CoordinateSystems.AxisInfo})">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.IFittedCoordinateSystem"/>.
            </summary>
            <remarks>The units of the axes in the fitted coordinate system will be 
            inferred from the units of the base coordinate system. If the affine map
            performs a rotation, then any mixed axes must have identical units. For
            example, a (lat_deg,lon_deg,height_feet) system can be rotated in the 
            (lat,lon) plane, since both affected axes are in degrees. But you 
            should not rotate this coordinate system in any other plane.</remarks>
            <param name="name">Name of coordinate system</param>
            <param name="baseCoordinateSystem">Base coordinate system</param>
            <param name="toBaseWkt"></param>
            <param name="arAxes"></param>
            <returns>Fitted coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateLocalCoordinateSystem(System.String,SharpMap.CoordinateSystems.ILocalDatum,SharpMap.CoordinateSystems.IUnit,System.Collections.Generic.List{SharpMap.CoordinateSystems.AxisInfo})">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.ILocalCoordinateSystem">local coordinate system</see>.
            </summary>
            <remarks>
             The dimension of the local coordinate system is determined by the size of 
            the axis array. All the axes will have the same units. If you want to make 
            a coordinate system with mixed units, then you can make a compound 
            coordinate system from different local coordinate systems.
            </remarks>
            <param name="name">Name of local coordinate system</param>
            <param name="datum">Local datum</param>
            <param name="unit">Units</param>
            <param name="axes">Axis info</param>
            <returns>Local coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateEllipsoid(System.String,System.Double,System.Double,SharpMap.CoordinateSystems.ILinearUnit)">
            <summary>
            Creates an <see cref="T:SharpMap.CoordinateSystems.Ellipsoid"/> from radius values.
            </summary>
            <seealso cref="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateFlattenedSphere(System.String,System.Double,System.Double,SharpMap.CoordinateSystems.ILinearUnit)"/>
            <param name="name">Name of ellipsoid</param>
            <param name="semiMajorAxis"></param>
            <param name="semiMinorAxis"></param>
            <param name="linearUnit"></param>
            <returns>Ellipsoid</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateFlattenedSphere(System.String,System.Double,System.Double,SharpMap.CoordinateSystems.ILinearUnit)">
            <summary>
            Creates an <see cref="T:SharpMap.CoordinateSystems.Ellipsoid"/> from an major radius, and inverse flattening.
            </summary>
            <seealso cref="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateEllipsoid(System.String,System.Double,System.Double,SharpMap.CoordinateSystems.ILinearUnit)"/>
            <param name="name">Name of ellipsoid</param>
            <param name="semiMajorAxis">Semi major-axis</param>
            <param name="inverseFlattening">Inverse flattening</param>
            <param name="linearUnit">Linear unit</param>
            <returns>Ellipsoid</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateProjectedCoordinateSystem(System.String,SharpMap.CoordinateSystems.IGeographicCoordinateSystem,SharpMap.CoordinateSystems.IProjection,SharpMap.CoordinateSystems.ILinearUnit,SharpMap.CoordinateSystems.AxisInfo,SharpMap.CoordinateSystems.AxisInfo)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.ProjectedCoordinateSystem"/> using a projection object.
            </summary>
            <param name="name">Name of projected coordinate system</param>
            <param name="gcs">Geographic coordinate system</param>
            <param name="projection">Projection</param>
            <param name="linearUnit">Linear unit</param>
            <param name="axis0">Primary axis</param>
            <param name="axis1">Secondary axis</param>
            <returns>Projected coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateProjection(System.String,System.String,System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter})">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.Projection"/>.
            </summary>
            <param name="name">Name of projection</param>
            <param name="wktProjectionClass">Projection class</param>
            <param name="parameters">Projection parameters</param>
            <returns>Projection</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateHorizontalDatum(System.String,SharpMap.CoordinateSystems.DatumType,SharpMap.CoordinateSystems.IEllipsoid,SharpMap.CoordinateSystems.Wgs84ConversionInfo)">
            <summary>
            Creates <see cref="T:SharpMap.CoordinateSystems.HorizontalDatum"/> from ellipsoid and Bursa-World parameters.
            </summary>
            <remarks>
            Since this method contains a set of Bursa-Wolf parameters, the created 
            datum will always have a relationship to WGS84. If you wish to create a
            horizontal datum that has no relationship with WGS84, then you can 
            either specify a <see cref="T:SharpMap.CoordinateSystems.DatumType">horizontalDatumType</see> of <see cref="F:SharpMap.CoordinateSystems.DatumType.HD_Other"/>, or create it via WKT.
            </remarks>
            <param name="name">Name of ellipsoid</param>
            <param name="datumType">Type of datum</param>
            <param name="ellipsoid">Ellipsoid</param>
            <param name="toWgs84">Wgs84 conversion parameters</param>
            <returns>Horizontal datum</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreatePrimeMeridian(System.String,SharpMap.CoordinateSystems.IAngularUnit,System.Double)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.PrimeMeridian"/>, relative to Greenwich.
            </summary>
            <param name="name">Name of prime meridian</param>
            <param name="angularUnit">Angular unit</param>
            <param name="longitude">Longitude</param>
            <returns>Prime meridian</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateGeographicCoordinateSystem(System.String,SharpMap.CoordinateSystems.IAngularUnit,SharpMap.CoordinateSystems.IHorizontalDatum,SharpMap.CoordinateSystems.IPrimeMeridian,SharpMap.CoordinateSystems.AxisInfo,SharpMap.CoordinateSystems.AxisInfo)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.GeographicCoordinateSystem"/>, which could be Lat/Lon or Lon/Lat.
            </summary>
            <param name="name">Name of geographical coordinate system</param>
            <param name="angularUnit">Angular units</param>
            <param name="datum">Horizontal datum</param>
            <param name="primeMeridian">Prime meridian</param>
            <param name="axis0">First axis</param>
            <param name="axis1">Second axis</param>
            <returns>Geographic coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateLocalDatum(System.String,SharpMap.CoordinateSystems.DatumType)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.ILocalDatum"/>.
            </summary>
            <param name="name">Name of datum</param>
            <param name="datumType">Datum type</param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateVerticalDatum(System.String,SharpMap.CoordinateSystems.DatumType)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.IVerticalDatum"/> from an enumerated type value.
            </summary>
            <param name="name">Name of datum</param>
            <param name="datumType">Type of datum</param>
            <returns>Vertical datum</returns>	
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateVerticalCoordinateSystem(System.String,SharpMap.CoordinateSystems.IVerticalDatum,SharpMap.CoordinateSystems.ILinearUnit,SharpMap.CoordinateSystems.AxisInfo)">
            <summary>
            Creates a <see cref="T:SharpMap.CoordinateSystems.IVerticalCoordinateSystem"/> from a <see cref="T:SharpMap.CoordinateSystems.IVerticalDatum">datum</see> and <see cref="T:SharpMap.CoordinateSystems.LinearUnit">linear units</see>.
            </summary>
            <param name="name">Name of vertical coordinate system</param>
            <param name="datum">Vertical datum</param>
            <param name="verticalUnit">Unit</param>
            <param name="axis">Axis info</param>
            <returns>Vertical coordinate system</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateGeocentricCoordinateSystem(System.String,SharpMap.CoordinateSystems.IHorizontalDatum,SharpMap.CoordinateSystems.ILinearUnit,SharpMap.CoordinateSystems.IPrimeMeridian)">
            <summary>
            Creates a <see cref="M:SharpMap.CoordinateSystems.CoordinateSystemFactory.CreateGeocentricCoordinateSystem(System.String,SharpMap.CoordinateSystems.IHorizontalDatum,SharpMap.CoordinateSystems.ILinearUnit,SharpMap.CoordinateSystems.IPrimeMeridian)"/> from a <see cref="T:SharpMap.CoordinateSystems.IHorizontalDatum">datum</see>, 
            <see cref="T:SharpMap.CoordinateSystems.ILinearUnit">linear unit</see> and <see cref="T:SharpMap.CoordinateSystems.IPrimeMeridian"/>.
            </summary>
            <param name="name">Name of geocentric coordinate system</param>
            <param name="datum">Horizontal datum</param>
            <param name="linearUnit">Linear unit</param>
            <param name="primeMeridian">Prime meridian</param>
            <returns>Geocentric Coordinate System</returns>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.TransformType">
            <summary>
            Semantic type of transform used in coordinate transformation.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.TransformType.Other">
            <summary>
            Unknown or unspecified type of transform.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.TransformType.Conversion">
            <summary>
            Transform depends only on defined parameters. For example, a cartographic projection.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.TransformType.Transformation">
            <summary>
            Transform depends only on empirically derived parameters. For example a datum transformation.
            </summary>
        </member>
        <member name="F:SharpMap.CoordinateSystems.Transformations.TransformType.ConversionAndTransformation">
            <summary>
            Transform depends on both defined and empirical parameters.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.IMathTransformFactory">
            <summary>
            Creates math transforms.
            </summary>
            <remarks>
            <para>CT_MathTransformFactory is a low level factory that is used to create CT_MathTransform objects. Many high level GIS applications will never need to use a CT_MathTransformFactory directly; they can use a CT_CoordinateTransformationFactory instead. However, the CT_MathTransformFactory interface is specified here, since it can be used directly by applications that wish to transform other types of coordinates (e.g. color coordinates, or image pixel coordinates).</para>
            <para>The following comments assume that the same vendor implements the math transform factory interfaces and math transform interfaces.</para>
            <para>A math transform is an object that actually does the work of applying formulae to coordinate values. The math transform does not know or care how the coordinates relate to positions in the real world. This lack of semantics makes implementing CT_MathTransformFactory significantly easier than it would be otherwise.</para>
            <para>For example CT_MathTransformFactory can create affine math transforms. The affine transform applies a matrix to the coordinates without knowing how what it is doing relates to the real world. So if the matrix scales Z values by a factor of 1000, then it could be converting meters into millimeters, or it could be converting kilometers into meters.</para>
            <para>Because math transforms have low semantic value (but high mathematical value), programmers who do not have much knowledge of how GIS applications use coordinate systems, or how those coordinate systems relate to the real world can implement CT_MathTransformFactory.</para>
            <para>The low semantic content of math transforms also means that they will be useful in applications that have nothing to do with GIS coordinates. For example, a math transform could be used to map color coordinates between different color spaces, such as converting (red, green, blue) colors into (hue, light, saturation) colors.</para>
            <para>Since a math transform does not know what its source and target coordinate systems mean, it is not necessary or desirable for a math transform object to keep information on its source and target coordinate systems.</para>
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransformFactory.CreateAffineTransform(System.Double[0:,0:])">
            <summary>
            Creates an affine transform from a matrix.
            </summary>
            <remarks>If the transform's input dimension is M, and output dimension is N, then the matrix will have size [N+1][M+1]. The +1 in the matrix dimensions allows the matrix to do a shift, as well as a rotation. The [M][j] element of the matrix will be the j'th ordinate of the moved origin. The [i][N] element of the matrix will be 0 for i less than M, and 1 for i equals M.</remarks>
            <param name="matrix"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransformFactory.CreateConcatenatedTransform(SharpMap.CoordinateSystems.Transformations.MathTransform,SharpMap.CoordinateSystems.Transformations.MathTransform)">
            <summary>
            Creates a transform by concatenating two existing transforms. A concatenated transform acts in the same way as applying two transforms, one after the other.
            </summary>
            <remarks>The dimension of the output space of the first transform must match the dimension of the input space in the second transform. If you wish to concatenate more than two transforms, then you can repeatedly use this method.</remarks>
            <param name="transform1"></param>
            <param name="transform2"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransformFactory.CreateFromWKT(System.String)">
            <summary>
            Creates a math transform from a Well-Known Text string.
            </summary>
            <param name="wkt"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransformFactory.CreateFromXML(System.String)">
            <summary>
            Creates a math transform from XML.
            </summary>
            <param name="xml"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransformFactory.CreateParameterizedTransform(System.String,System.Collections.Generic.List{SharpMap.CoordinateSystems.Parameter})">
            <summary>
            Creates a transform from a classification name and parameters.
            </summary>
            <remarks>
            The client must ensure that all the linear parameters are expressed in meters, and all the angular parameters are expressed in degrees. Also, they must supply "semi_major" and "semi_minor" parameters for cartographic projection transforms.
            </remarks>
            <param name="classification"></param>
            <param name="parameters"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransformFactory.CreatePassThroughTransform(System.Int32,SharpMap.CoordinateSystems.Transformations.MathTransform)">
            <summary>
            Creates a transform which passes through a subset of ordinates to another transform.
            </summary>
            <remarks>
            This allows transforms to operate on a subset of ordinates. For example, if you have (Lat,Lon,Height) coordinates, then you may wish to convert the height values from meters to feet without affecting the (Lat,Lon) values. If you wanted to affect the (Lat,Lon) values and leave the Height values alone, then you would have to swap the ordinates around to (Height,Lat,Lon). You can do this with an affine map.
            </remarks>
            <param name="firstAffectedOrdinate"></param>
            <param name="subTransform"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransformFactory.IsParameterAngular(System.String)">
            <summary>
            Tests whether parameter is angular. Clients must ensure that all angular parameter values are in degrees.
            </summary>
            <param name="parameterName"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.IMathTransformFactory.IsParameterLinear(System.String)">
            <summary>
            Tests whether parameter is linear. Clients must ensure that all linear parameter values are in meters.
            </summary>
            <param name="parameterName"></param>
            <returns></returns>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.CoordinateTransformationFactory">
            <summary>
            Creates coordinate transformations.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.CoordinateTransformationFactory.CreateFromCoordinateSystems(SharpMap.CoordinateSystems.ICoordinateSystem,SharpMap.CoordinateSystems.ICoordinateSystem)">
            <summary>
            Creates a transformation between two coordinate systems.
            </summary>
            <remarks>
            This method will examine the coordinate systems in order to construct
            a transformation between them. This method may fail if no path between 
            the coordinate systems is found, using the normal failing behavior of 
            the DCP (e.g. throwing an exception).</remarks>
            <param name="sourceCS">Source coordinate system</param>
            <param name="targetCS">Target coordinate system</param>
            <returns></returns>		
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.CoordinateTransformationFactory.CreateGeog2Geog(SharpMap.CoordinateSystems.IGeographicCoordinateSystem,SharpMap.CoordinateSystems.IGeographicCoordinateSystem)">
            <summary>
            Geographic to geographic transformation
            </summary>
            <remarks>Adds a datum shift if nessesary</remarks>
            <param name="source"></param>
            <param name="target"></param>
            <returns></returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Transformations.CoordinateTransformationFactory.CreateGeoc2Geoc(SharpMap.CoordinateSystems.IGeocentricCoordinateSystem,SharpMap.CoordinateSystems.IGeocentricCoordinateSystem)">
            <summary>
            Geocentric to Geocentric transformation
            </summary>
            <param name="source"></param>
            <param name="target"></param>
            <returns></returns>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Projections.Mercator">
            <summary>
            Implements the Mercator projection.
            </summary>
            <remarks>
            <para>This map projection introduced in 1569 by Gerardus Mercator. It is often described as a cylindrical projection,
            but it must be derived mathematically. The meridians are equally spaced, parallel vertical lines, and the
            parallels of latitude are parallel, horizontal straight lines, spaced farther and farther apart as their distance
            from the Equator increases. This projection is widely used for navigation charts, because any straight line
            on a Mercator-projection map is a line of constant true bearing that enables a navigator to plot a straight-line
            course. It is less practical for world maps because the scale is distorted; areas farther away from the equator
            appear disproportionately large. On a Mercator projection, for example, the landmass of Greenland appears to be
            greater than that of the continent of South America; in actual area, Greenland is smaller than the Arabian Peninsula.
            </para>
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.Mercator.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter})">
            <summary>
            Initializes the MercatorProjection object with the specified parameters to project points. 
            </summary>
            <param name="parameters">ParameterList with the required parameters.</param>
            <remarks>
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.Mercator.#ctor(System.Collections.Generic.List{SharpMap.CoordinateSystems.ProjectionParameter},System.Boolean)">
            <summary>
            Initializes the MercatorProjection object with the specified parameters.
            </summary>
            <param name="parameters">List of parameters to initialize the projection.</param>
            <param name="isInverse">Indicates whether the projection forward (meters to degrees or degrees to meters).</param>
            <remarks>
            <para>The parameters this projection expects are listed below.</para>
            <list type="table">
            <listheader><term>Items</term><description>Descriptions</description></listheader>
            <item><term>central_meridian</term><description>The longitude of the point from which the values of both the geographical coordinates on the ellipsoid and the grid coordinates on the projection are deemed to increment or decrement for computational purposes. Alternatively it may be considered as the longitude of the point which in the absence of application of false coordinates has grid coordinates of (0,0).</description></item>
            <item><term>latitude_of_origin</term><description>The latitude of the point from which the values of both the geographical coordinates on the ellipsoid and the grid coordinates on the projection are deemed to increment or decrement for computational purposes. Alternatively it may be considered as the latitude of the point which in the absence of application of false coordinates has grid coordinates of (0,0).</description></item>
            <item><term>scale_factor</term><description>The factor by which the map grid is reduced or enlarged during the projection process, defined by its value at the natural origin.</description></item>
            <item><term>false_easting</term><description>Since the natural origin may be at or near the centre of the projection and under normal coordinate circumstances would thus give rise to negative coordinates over parts of the mapped area, this origin is usually given false coordinates which are large enough to avoid this inconvenience. The False Easting, FE, is the easting value assigned to the abscissa (east).</description></item>
            <item><term>false_northing</term><description>Since the natural origin may be at or near the centre of the projection and under normal coordinate circumstances would thus give rise to negative coordinates over parts of the mapped area, this origin is usually given false coordinates which are large enough to avoid this inconvenience. The False Northing, FN, is the northing value assigned to the ordinate.</description></item>
            </list>
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.Mercator.DegreesToMeters(System.Double[])">
            <summary>
            Converts coordinates in decimal degrees to projected meters.
            </summary>
            <remarks>
            <para>The parameters this projection expects are listed below.</para>
            <list type="table">
            <listheader><term>Items</term><description>Descriptions</description></listheader>
            <item><term>longitude_of_natural_origin</term><description>The longitude of the point from which the values of both the geographical coordinates on the ellipsoid and the grid coordinates on the projection are deemed to increment or decrement for computational purposes. Alternatively it may be considered as the longitude of the point which in the absence of application of false coordinates has grid coordinates of (0,0).  Sometimes known as ""central meridian""."</description></item>
            <item><term>latitude_of_natural_origin</term><description>The latitude of the point from which the values of both the geographical coordinates on the ellipsoid and the grid coordinates on the projection are deemed to increment or decrement for computational purposes. Alternatively it may be considered as the latitude of the point which in the absence of application of false coordinates has grid coordinates of (0,0).</description></item>
            <item><term>scale_factor_at_natural_origin</term><description>The factor by which the map grid is reduced or enlarged during the projection process, defined by its value at the natural origin.</description></item>
            <item><term>false_easting</term><description>Since the natural origin may be at or near the centre of the projection and under normal coordinate circumstances would thus give rise to negative coordinates over parts of the mapped area, this origin is usually given false coordinates which are large enough to avoid this inconvenience. The False Easting, FE, is the easting value assigned to the abscissa (east).</description></item>
            <item><term>false_northing</term><description>Since the natural origin may be at or near the centre of the projection and under normal coordinate circumstances would thus give rise to negative coordinates over parts of the mapped area, this origin is usually given false coordinates which are large enough to avoid this inconvenience. The False Northing, FN, is the northing value assigned to the ordinate .</description></item>
            </list>
            </remarks>
            <param name="lonlat">The point in decimal degrees.</param>
            <returns>Point in projected meters</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.Mercator.MetersToDegrees(System.Double[])">
            <summary>
            Converts coordinates in projected meters to decimal degrees.
            </summary>
            <param name="p">Point in meters</param>
            <returns>Transformed point in decimal degrees</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.Projections.Mercator.Inverse">
            <summary>
            Returns the inverse of this projection.
            </summary>
            <returns>IMathTransform that is the reverse of the current projection.</returns>
        </member>
        <member name="T:SharpMap.CoordinateSystems.ILocalDatum">
            <summary>
            Local datum. If two local datum objects have the same datum type and name, 
            then they can be considered equal. This means that coordinates can be
            transformed between two different local coordinate systems, as long as
            they are based on the same local datum.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.GeographicCoordinateSystem">
            <summary>
            A coordinate system based on latitude and longitude. 
            </summary>
            <remarks>
            Some geographic coordinate systems are Lat/Lon, and some are Lon/Lat. 
            You can find out which this is by examining the axes. You should also 
            check the angular units, since not all geographic coordinate systems 
            use degrees.
            </remarks>
        </member>
        <member name="M:SharpMap.CoordinateSystems.GeographicCoordinateSystem.#ctor(SharpMap.CoordinateSystems.IAngularUnit,SharpMap.CoordinateSystems.IHorizontalDatum,SharpMap.CoordinateSystems.IPrimeMeridian,System.Collections.Generic.List{SharpMap.CoordinateSystems.AxisInfo},System.String,System.String,System.Int64,System.String,System.String,System.String)">
            <summary>
            Creates an instance of a Geographic Coordinate System
            </summary>
            <param name="angularUnit">Angular units</param>
            <param name="horizontalDatum">Horizontal datum</param>
            <param name="primeMeridian">Prime meridian</param>
            <param name="axisInfo">Axis info</param>
            <param name="name">Name</param>
            <param name="authority">Authority name</param>
            <param name="authorityCode">Authority-specific identification code.</param>
            <param name="alias">Alias</param>
            <param name="abbreviation">Abbreviation</param>
            <param name="remarks">Provider-supplied remarks</param>
        </member>
        <member name="M:SharpMap.CoordinateSystems.GeographicCoordinateSystem.GetUnits(System.Int32)">
            <summary>
            Gets units for dimension within coordinate system. Each dimension in 
            the coordinate system has corresponding units.
            </summary>
            <param name="dimension">Dimension</param>
            <returns>Unit</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.GeographicCoordinateSystem.GetWgs84ConversionInfo(System.Int32)">
            <summary>
            Gets details on a conversion to WGS84.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.GeographicCoordinateSystem.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeographicCoordinateSystem.WGS84">
            <summary>
            Creates a decimal degrees geographic coordinate system based on the WGS84 ellipsoid, suitable for GPS measurements
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeographicCoordinateSystem.AngularUnit">
            <summary>
            Gets or sets the angular units of the geographic coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeographicCoordinateSystem.PrimeMeridian">
            <summary>
            Gets or sets the prime meridian of the geographic coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeographicCoordinateSystem.NumConversionToWGS84">
            <summary>
            Gets the number of available conversions to WGS84 coordinates.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeographicCoordinateSystem.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeographicCoordinateSystem.XML">
            <summary>
            Gets an XML representation of this object
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.GeocentricCoordinateSystem">
            <summary>
            A 3D coordinate system, with its origin at the center of the Earth.
            </summary>
        </member>
        <member name="M:SharpMap.CoordinateSystems.GeocentricCoordinateSystem.GetUnits(System.Int32)">
            <summary>
            Gets units for dimension within coordinate system. Each dimension in 
            the coordinate system has corresponding units.
            </summary>
            <param name="dimension">Dimension</param>
            <returns>Unit</returns>
        </member>
        <member name="M:SharpMap.CoordinateSystems.GeocentricCoordinateSystem.EqualParams(System.Object)">
            <summary>
            Checks whether the values of this instance is equal to the values of another instance.
            Only parameters used for coordinate system are used for comparison.
            Name, abbreviation, authority, alias and remarks are ignored in the comparison.
            </summary>
            <param name="obj"></param>
            <returns>True if equal</returns>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeocentricCoordinateSystem.WGS84">
            <summary>
            Creates a geocentric coordinate system based on the WGS84 ellipsoid, suitable for GPS measurements
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeocentricCoordinateSystem.HorizontalDatum">
            <summary>
            Returns the HorizontalDatum. The horizontal datum is used to determine where
            the centre of the Earth is considered to be. All coordinate points will be 
            measured from the centre of the Earth, and not the surface.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeocentricCoordinateSystem.LinearUnit">
            <summary>
            Gets the units used along all the axes.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeocentricCoordinateSystem.PrimeMeridian">
            <summary>
            Returns the PrimeMeridian.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeocentricCoordinateSystem.WKT">
            <summary>
            Returns the Well-known text for this object
            as defined in the simple features specification.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.GeocentricCoordinateSystem.XML">
            <summary>
            Gets an XML representation of this object
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.Transformations.CoordinateTransformationAuthorityFactory">
            <summary>
            Creates coordinate transformation objects from codes. The codes are maintained by an external authority. A commonly used authority is EPSG, which is also used in the GeoTIFF standard
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.IVerticalCoordinateSystem">
            <summary>
            A one-dimensional coordinate system suitable for vertical measurements.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IVerticalCoordinateSystem.VerticalDatum">
            <summary>
            Gets the vertical datum, which indicates the measurement method
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.IVerticalCoordinateSystem.VerticalUnit">
            <summary>
            Gets the units used along the vertical axis.
            </summary>
        </member>
        <member name="T:SharpMap.CoordinateSystems.ICompoundCoordinateSystem">
            <summary>
            An aggregate of two coordinate systems (CRS). One of these is usually a 
            CRS based on a two dimensional coordinate system such as a geographic or
            a projected coordinate system with a horizontal datum. The other is a 
            vertical CRS which is a one-dimensional coordinate system with a vertical
            datum.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ICompoundCoordinateSystem.HeadCS">
            <summary>
            Gets first sub-coordinate system.
            </summary>
        </member>
        <member name="P:SharpMap.CoordinateSystems.ICompoundCoordinateSystem.TailCS">
            <summary>
            Gets second sub-coordinate system.
            </summary>
        </member>
    </members>
</doc>
